Аргументы

X

матрица логических чисел, закодированных целых чисел или десятичных вещественных или комплексных чисел. Матрица строк, представляющая литеральные большие целые числа для int64 и uint64.

y

матрица целых чисел, закодированная по 1, 2, 4 или 8 байтам. Её размеры - это размеры X.

Описание

Эти функции преобразуют и хранят данные в виде одно-, двух-, четырёх- или восьмибайтных целых чисел. Эти типы данных особо полезны для хранения больших объектов таких, как изображения, длинные сигналы,...

Если какие-то десятичные элементы X имеют дробную часть, то она всегда обрезается до 0. Example: int8([-3.6, -2.5, -1.4, 1.3, 3.5, 6.7]) // = [-3, -2, -1, 1, 3, 6]. Значения элемнтов X, которые вне целевого интервала, заворачиваются (не ограничиваются). Например: int8([127 128 129 130]) // = [127 -128 -127 -126]. uint8([254 255 256 257]) // = [254 255 0 1]. -%inf всегда преобразуется в нижний предел интервала (см. ниже). %inf всегда преобразуется в верхний предел интервала (см. ниже).. %nan всегда преобразуется в 0. Если X комплексная, то мнимые части игнорируются. Преобразуются и возвращаются только вещественные части. [%f %t] всегда преобразуются в [0 1].

Чтение больших литеральных целых числе с помощью int64 или uint64: Любой ввод, например int64(1000000000000000000) безоговорочно считает 1000000000000000000, как десятичное число, чья мантисса закодирована только 53 битами < 64 битами. Следовательно, эта мантисса чаще всего обрезается, а закодированное целое число, которое мы получим после обрезания плавающей точки, не равно введённому числу. Во избежание этого эффекта, целое число может быть указано в виде строки: int64("1000000000000000000") возвращает ожидаемое целое число, без потери точности. Для более детального пояснения эфекта обрезания больших целых чисел, обарщайтесь к странице double().

Преобразование [] всегда сохраняет в исходном виде, тип 1 (десятичный тип).

Примеры

Округление до 0 и завороты, и особые значения:

int8([-11.7 -8.5 -6.4  6.4 8.5 11.7])
int8([-130 -129 -128 -127 126 127 128 129])
a = -129 + 256*(-3:3)
int8(a)
int8([-%inf %inf %nan])

--> int8([-11.7 -8.5 -6.4  6.4 8.5 11.7])
 ans  =
 -11 -8 -6  6  8  11

--> int8([-130 -129 -128 -127 126 127 128 129])
 ans  =
  126  127 -128 -127  126  127 -128 -127

--> a = -129 + 256*(-3:3)
 a  =
  -897.  -641.  -385.  -129.   127.   383.   639.

--> int8(a)
 ans  =
  127  127  127  127  127  127  127

--> int8([-%inf %inf %nan])
 ans  =
 -128  127  0

О заворотах и верхних пределах беззнаковых целых чисел:

uint8([-1 %inf])
uint16([-1 %inf])
uint32([-1 %inf])
uint64([-1 %inf])

--> uint8([-1 %inf])
 ans  =
  255  255

--> uint16([-1 %inf])
 ans  =
  65535  65535

--> uint32([-1 %inf])
 ans  =
  4294967295  4294967295

--> uint64([-1 %inf])
 ans  =
  18446744073709551615  18446744073709551615

Преобразование 64-битных целых чисел в десятичные числа со снижением их точности:

i = uint64(2)^63 - 600
i - uint64(double(i))

--> i = uint64(2)^63 - 600
 i  =
  9223372036854775208

--> i - uint64(double(i))
 ans  =
  424

Преобразование логических и комплексных чисел:

int8([%f %t])

int8(-10.2 + 3.4*%i)
uint8(-10.2 + 3.4*%i)

--> int8([%f %t])
 ans  =
  0  1

--> int8(-10.2 + 3.4*%i)
 ans  =
 -10

--> uint8(-10.2 + 3.4*%i)
 ans  =
  246

Чтение литеральных int64 или uint64 целых чисел, больше, чем 2^53, без эффекта обрезания плавающей точки:

a = [uint64(1000000000000001000) ; uint64("1000000000000001000")]
typeof(a)

a = [int64(-1000000000000001000) ; int64("-1000000000000001000")]
typeof(a)

--> a = [uint64(1000000000000001000) ; uint64("1000000000000001000")]
 a  =
  1000000000000001024
  1000000000000001000

--> typeof(a)
 ans  =
  "uint64"

--> a = [int64(-1000000000000001000) ; int64("-1000000000000001000")]
 a  =
 -1000000000000001024
 -1000000000000001000

--> typeof(a)
 ans  =
  "int64"

[] не преобразуется:

i = uint16(3);
i(1,2) = 5.6
typeof(i)

i = uint16([])
i(1,2) = 2.3
typeof(i)

--> i = uint16(3);
--> i(1,2) = 5.6
 i  =
  3  5

--> typeof(i)
 ans  =
 uint16


--> i = uint16([])
 i  =
    []

--> i(1,2) = 2.3
 i  =
   0.   2.3

--> typeof(i)
 ans  =
 constant

Смотрите также

• iconvert — преобразование в 1- или 8-байтное представление целого числа
• inttype — возвращает тип целых чисел, используемых в типах целочисленных данных
• double — converts inttype integers or booleans into decimal encoding
• dec2bin — преобразование из десятичной системы счисления в двоичную
• dec2base — преобразование десятичного числа в число системы счисления по основанию N в строке

История