Kotlin целое от деления

Kotlin поддерживает базовые арифметические операции:

val x = 5 val y = 6 val z = x + y println(z) // z = 11

val x = 5 val y = 6 val z = x - y // z = -1

val x = 5 val y = 6 val z = x * y // z = 30

val x = 60 val y = 10 val z = x / y // z = 6

При этом если в операции деления оба операнда представляют целые числа, то результатом тоже будет целое число, а если в процессе деления образовалась дробная часть, то она отбрасывается:

Так в данном случае, хотя если согласно стандартной математике разделить 11 на 5, то получится 2.2. Однако поскольку оба операнда представляют целочисленный тип, а именно тип Int , то дробная часть — 0.2 отрабрасывается, поэтому результатом будет число 2, а переменная z будет представлять тип Int . Чтобы результатом было дробное число, один из операндов должен представлять число с плавающей точкой:

val x = 65 val y = 10 val z = x % y // z = 5

var x = 5 val y = ++x println(x) // x = 6 println(y) // y = 6

var x = 5 val y = x++ println(x) // x = 6 println(y) // y = 5

var x = 5 val y = --x println(x) // x = 4 println(y) // y = 4

var x = 5 val y = x-- println(x) // x = 4 println(y) // y = 5

Также есть ряд операций присвоения, которые сочетают арифметические операции и присвоение:

+= : присваивание после сложения. Присваивает левому операнду сумму левого и правого операндов: A += B эквивалентно A = A + B
-= : присваивание после вычитания. Присваивает левому операнду разность левого и правого операндов: A -= B эквивалентно A = A — B
*= : присваивание после умножения. Присваивает левому операнду произведение левого и правого операндов: A *= B эквивалентно A = A * B
/= : присваивание после деления. Присваивает левому операнду частное левого и правого операндов: A /= B эквивалентно A = A / B
%= : присваивание после деления по модулю. Присваивает левому операнду остаток от целочисленного деления левого операнда на правый: A %= B эквивалентно A = A % B

Поразрядные операции

Ряд операций выполняется над двоичными разрядами числа. Здесь важно понимать, как выглядит двоичное представление тех или иных чисел. В частности, число 4 в двоичном виде — 100, а число 15 — 1111.

Есть следующие поразрядные операторы (они применяются только к данным типов Int и Long):

val z = 12 shr 2 // z = 1100 >> 2 = 11 println(z) // z = 3 val d = 0b1100 shr 2 println(d) // d = 3

val z = 12 ushr 2 // z = 1100 >> 2 = 11 println(z) // z = 3

val x = 5 // 101 val y = 6 // 110 val z = x and y // z = 101 & 110 = 100 println(z) // z = 4 val d = 0b101 and 0b110 println(d) // d = 4

val x = 5 // 101 val y = 6 // 110 val z = x or y // z = 101 | 110 = 111 println(z) // z = 7 val d = 0b101 or 0b110 println(d) // d = 7

val x = 5 // 101 val y = 6 // 110 val z = x xor y // z = 101 ^ 110 = 011 println(z) // z = 3 val d = 0b101 xor 0b110 println(d) // d = 3

val b = 11 // 1011 val c = b.inv() println(c) // -12

Источник

Арифметические операции в Kotlin

Проще всего разобраться с операциями можно с помощью арифметики. Операция сложения берет два числа и преобразует их в сумму. Операция вычитания берет два числа и преобразует их в разность. Во всех приложениях вы найдете простую арифметику — от подсчета количества лайков до расчета правильного размера и положения кнопки или окна — числа и правда везде!

Простые математические операции в Kotlin

Все операции в Kotlin используют символ, известный как оператор, для указания типа осуществляемой операции. Рассмотрим четыре арифметические операции, с которым вы знакомы с первого класса: сложение, вычитание, умножение и деление.

Для данных операций в Kotlin используются следующие операторы:

Данные операторы используются следующим образом:

Каждая из данных строчек является выражением. У выражения есть значение. В данных случаях у всех четырех выражений одинаковые значения: 8 . Вы набираете код для выполнения операций по аналогии с написанием примеров на бумаге.

В IDE вы увидите значения выражений в выводе на консоли с помощью команды println():

Если хотите, можете убрать пробелы возле оператора:

Разницы нет. Вы можете даже использовать варианты с пробелами и без вперемежку. К примеру:

Однако зачастую удобнее читать выражения с пробелами возле оператора.

Десятичные числа в Kotlin

Во всех операциях выше использовались целые числа, которые относятся к типу integer. Однако не все числа целые.

Рассмотрим следующий пример:

Результатом данной операции будет число 3 . Это потому что, если вы используете в выражении только целые числа, Kotlin сделает результат также целым числом. В данном случае результат округляется до ближайшего целого числа.

Вы можете указать Kotlin, что нужно использовать десятичные числа, записав их в следующей форме:

На этот раз результатом будет число 3.142857142857143 .

Операция для получения остатка % в Kotlin

Четыре операции, с которыми мы работали до сих пор, легко понять, потому что вы с ними хорошо знакомы в жизни. В Kotlin также есть более сложные операции, которые вы можете использовать. Это стандартные математические операции, только менее распространенные. Рассмотрим их.

Сначала разберем операцию остатка, или операцию по модулю. При делении числителя на знаменатель — результатом будет целое число, а также остаток. Этот остаток и является результатом операции по модулю. Например, 10 по модулю 3 равно 1, потому что 3 трижды переходит в 10 с остатком 1.

В Kotlin оператором остатка является символ % , который используется следующим образом:

В данном случае результатом будет число 8, которое является остатком при делении 28 на 10. Если вам нужно посчитать то же самое, используя десятичные числа, это можно сделать следующим образом:

Результат идентичен % без десятичных чисел, что можно увидеть на выводе при использовании указателя формата:

Операции смещения в Kotlin

Операции правого и левого смещения (Shift) принимают двоичную форму десятичного числа и смещают цифры налево или направо соответственно. Затем они возвращают десятичную форму нового двоичного числа.

К примеру, десятичное число 14 в бинарном виде будет состоять из восьми цифр — 00001110 . Смещение на два пункта влево приведет к числу 00111000 , которое равно 56 в десятичной системе.

Далее дана схема того, что происходит во время операции смещения:

Цифры, которые приходят на замену пустым местам, становятся 0. Отсеченные числа будут потеряны. Смещение вправо аналогично, но цифры сдвигаются в правую часть. Функции Kotlin для данных двух операций являются следующими:

Это инфиксные функции, которые помещаются между операндами, чтобы вызов функции выглядел как операция. Позже мы подробнее рассмотрим инфиксные функции в Kotlin.

Источник

Operations

kotlin

Kotlin поддерживает стандартный набор арифметических операций над числами: + , — , * , / , % . Они объявляются членами соответствующих классов.

fun main() < //sampleStart println(1 + 2) println(2_500_000_000L - 1L) println(3.14 * 2.71) println(10.0 / 3) //sampleEnd >

Вы также можете переопределить эти операторы для пользовательских классов. Дополнительные сведения см. в разделе Перегрузка операторов .

Деление целых чисел

Деление между целыми числами всегда возвращает целое число.Любая дробная часть отбрасывается.

fun main() < //sampleStart val x = 5 / 2 // println (x == 2.5) // ОШИБКА: оператор '==' нельзя применить к 'Int' и 'Double' println(x == 2) //sampleEnd >

Это справедливо для деления между любыми двумя целыми типами.

fun main() < //sampleStart val x = 5L / 2 println(x == 2L) //sampleEnd >

Чтобы вернуть тип с плавающей точкой,явно преобразуйте один из аргументов к типу с плавающей точкой.

fun main() < //sampleStart val x = 5 / 2.toDouble() println(x == 2.5) //sampleEnd >

Bitwise operations

Kotlin предоставляет набор побитовых операций над целыми числами. Они работают на двоичном уровне напрямую с битами представления чисел. Побитовые операции представлены функциями, которые можно вызывать в инфиксной форме. Их можно применять только к Int и Long .

val x = (1 shl 2) and 0x000FF000

Вот полный список побитовых операций:

shl(bits) – знаковый сдвиг влево
shr(bits) – знаковый сдвиг вправо
ushr(bits) – беззнаковый сдвиг вправо
and(bits) – побитовое и
or(bits) – побитовое или
xor(bits) xor (bits) – побитовое исключающее ИЛИ
inv() – побитовая инверсия

Сравнение чисел с плавающей точкой

В этом разделе рассматриваются операции над числами с плавающей точкой:

Проверки равенства: a == b и a != b
Операторы сравнения: a < b , a >b , a = b
a..b экземпляра диапазона и проверка диапазона: a..b , x in a..b , x !in a..b

Когда операнды a и b статически известны как Float или Double или их эквиваленты, допускающие значение NULL (тип объявлен или выведен или является результатом интеллектуального приведения ), операции над числами и диапазоном, который они формируют, следуют IEEE 754 . Стандарт для арифметики с плавающей запятой .

Однако для поддержки общих вариантов использования и обеспечения полного упорядочения, когда операнды не являются статически типизированными как числа с плавающей запятой (например , Any , Comparable <. >, параметр типа), операции используют реализации equals и compareTo для Float и Double , которые не соответствуют стандарту, так что:

NaN считается равным самому себе
NaN считается большим, чем любой другой элемент, включая POSITIVE_INFINITY
-0.0 считается меньше 0.0

Unsigned integers

В дополнение к целочисленным типам Kotlin предоставляет следующие типы для целых чисел без знака:

UByte : 8-битное целое число без знака, от 0 до 255.
UShort : 16-разрядное целое число без знака, от 0 до 65535.
UInt : 32-битное целое число без знака, от 0 до 2 ^ 32-1.
ULong : 64-битное целое число без знака, от 0 до 2 ^ 64-1.

Безподписные типы поддерживают большинство операций своих подписанных контрагентов.

Изменение типа с беззнакового на подписанный аналог (и наоборот) является бинарным несовместимым изменением.

Беззнаковые массивы и диапазоны

Беззнаковые массивы и операции над ними находятся в Beta . Они могут быть изменены несовместимо в любое время. Требуется согласие (подробности см. ниже).

Как и в случае с примитивами,каждый беззнаковый тип имеет соответствующий тип,который представляет массивы этого типа:

UByteArray : массив байтов без знака
UShortArray : массив коротких замыканий без знака
UIntArray : массив беззнаковых целых чисел
ULongArray : массив длинных беззнаковых чисел

Как и массивы целых чисел со знаком, они предоставляют API, аналогичный классу Array , без дополнительных затрат на упаковку.

При использовании неподписанных массивов вы получите предупреждение о том, что эта функция еще не стабильна. Чтобы удалить предупреждение, включите аннотацию @ExperimentalUnsignedTypes . Вам решать, должны ли ваши клиенты явно соглашаться на использование вашего API, но имейте в виду, что неподписанный массив не является стабильной функцией, поэтому API, который их использует, может быть нарушен из-за изменений в языке. Узнайте больше о требованиях для подписки .

Диапазоны и последовательности поддерживаются для UInt и ULong классами UIntRange , UIntProgression , ULongRange и ULongProgression . Вместе с целочисленными типами без знака эти классы стабильны.

Literals

Чтобы упростить использование целых чисел без знака, Kotlin предоставляет возможность пометить целочисленный литерал суффиксом, указывающим на конкретный беззнаковый тип (аналогично Float или Long ):

u и U тегируют беззнаковые литералы. Точный тип определяется на основе ожидаемого типа. Если ожидаемый тип не UInt , компилятор будет использовать UInt или ULong в зависимости от размера литерала.

val b: UByte = 1u // UByte, предусмотрен ожидаемый тип val s: UShort = 1u // UShort, указан ожидаемый тип val l: ULong = 1u // ULong, предоставлен ожидаемый тип val a1 = 42u // UInt: не указан ожидаемый тип, константа подходит для UInt val a2 = 0xFFFF_FFFF_FFFFu // ULong: не указан ожидаемый тип, константа не помещается в UInt

val a = 1UL // ULong, даже если не указан ожидаемый тип и константа помещается в UInt

Further discussion

Технические подробности и дальнейшее обсуждение см . в предложении по языку для неподписанных типов .

Источник