bitcmp

Аргументы

x, y

массивы знаковых и беззнаковых целых чисел (int8, .., uint64) или положительных десятичных целых чисел. Поддерживаются гиперматрицы. x и y одного типа целого числа и одинакового размера.

bitnum

положительное кодированное иди десятичное целое число или массив положительных кодированных или десятичных целых чисел размером, равным size(x): учитываются и инвертируются биты от №1 до №bitnum в x. В соответствии с типом целого числа x, bitnum должен быть в интервале [1, bitmax], где bitmax:

inttype :	int8	uint8	int16	uint16	int32	uint32	int64	uint64	decimal
bitmax :	8	8	16	16	32	32	64	64	1024

Значение по умолчанию bitnum зависит от типа входного целого числа:

• bitnum = bitmax для кодированных целых чисел
• bitnum = 53 для десятичных целых чисел x ≤ 1/%eps
• bitnum = int(log2(x))+1 для десятичных целых чисел x > 1/%eps.

Описание

bitcmp(x) вычисляет двоичный дополнительный код каждого элемента x и выдаёт его в соответствующем элементе y.

В следующем описании 2^0 соответствует биту №1. Целое число, чей наивысший бит №n, находится в интервале [2^(n-1), 2^n-1].

Для x такого, что abs(x) ≥ 2^bitnum, его биты от #(bitnum+1) до №(int(log2(x))+1) игнорируются. Рассматриваются и инвертируются только его биты от №1 до №bitnum

Пример:

--> bitget(180, 1:8)
 ans  =
   0.   0.   1.   0.   1.   1.   0.   1.
--> bitcmp(180, 4)
 ans  =
   11.
--> bitget(11, 1:8)
 ans  =
   1.   1.   0.   1.   0.   0.   0.   0.

Для x такого, что abs(x) < 2^bitnum, биты от №(int(log2(x))+2) до №bitnum дополняются нулями. Затем рассматриваются и инвертируются все биты от №1 до №bitnum.

Пример:

--> x = 30; int(log2(30))+2
 ans  =
   6.
--> bitget(30, 1:10)
 ans  =
   0.   1.   1.   1.   1.   0.   0.   0.   0.   0.
--> bitcmp(30, 7)
 ans  =
   97.
--> bitget(97, 1:10)
 ans  =
   1.   0.   0.   0.   0.   1.   1.   0.   0.   0.

Примеры

x = uint8(13); b = bitget(x, 1:8) c = bitcmp(x, 8) bitget(c, 1:8) 1 - b

--> b = bitget(x, 1:8)
 b  =
  1  0  1  1  0  0  0  0

--> c = bitcmp(x, 8)
 c  =
  242

--> bitget(c, 1:8)
 ans  =
  0  1  0  0  1  1  1  1

--> 1 - b
 ans  =
  0  1  0  0  1  1  1  1

Принимаются отрицательные кодированные целые числа:

bitcmp(int8([-71 -34 -1 0 33 70])) bitcmp(int8([-71 -34 -1 0 33 70]), 8) bitcmp(int8([-71 -34 -1 0 33 70]), 7) bitcmp(int8([-71 -34 -1 0 33 70]), 6) bitcmp(int8([-71 -34 -1 0 33 70]), 5) bitcmp(int8([-71 -34 -1 0 33 70]), 4)

--> bitcmp(int8([-71 -34 -1 0 33 70]))
 ans  =
  70  33  0 -1 -34 -71

--> bitcmp(int8([-71 -34 -1 0 33 70]), 8)
 ans  =
  70  33  0 -1 -34 -71

--> bitcmp(int8([-71 -34 -1 0 33 70]), 7)
 ans  =
  70  33  0  127  94  57

--> bitcmp(int8([-71 -34 -1 0 33 70]), 6)
 ans  =
  6  33  0  63  30  57

--> bitcmp(int8([-71 -34 -1 0 33 70]), 5)
 ans  =
  6  1  0  31  30  25

--> bitcmp(int8([-71 -34 -1 0 33 70]), 4)
 ans  =
  6  1  0  15  14  9

Можно работать с 64-битными большими целыми числами:

b = (rand(1,62)<0.5)*1; x = sum(b .* (uint64(2).^(0:61))) r = bitcmp(x) bg = bitget(r, 1:62); [msprintf("%d ",b(:)) ; msprintf("%d ",bg(:))]

--> x = sum(b .* (uint64(2).^(0:61)))
 x  =
  4154509482123930814

--> r = bitcmp(x)
 r  =
  14292234591585620801

--> bg = bitget(r, 1:62);
--> [msprintf("%d ",b(:)) ; msprintf("%d ",bg(:))]
 ans  =
  "0 1 1 1 1 1 0 1 0 0 1 1 0 1 0 0 ... 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 1 0 1 1 0 0 1 1 1 "
  "1 0 0 0 0 0 1 0 1 1 0 0 1 0 1 1 ... 0 1 1 1 1 0 1 1 0 0 0 0 0 1 1 0 1 0 0 1 1 0 0 0 "

bitnum может быть массивом:

bitcmp([0 0 0 0 0], 3:7)

--> bitcmp([0 0 0 0 0], 3:7)
 ans  =
   7.   15.   31.   63.   127.

bitnum может быть > 52:

format(22) bitcmp(2^70, 65) sum(2.^(13:64)) // 52 высшие биты

--> bitcmp(2^70, 65)
 ans  =
   36893488147419095040.

--> sum(2.^(13:64))
 ans  =
   36893488147419095040.

Могут обрабатываться огромные десятичные числа:

format(22) log2(1e100) r = bitcmp(1e100, 333) bitcmp(1e100) // bitnum = int(log2(x)) + 1 is used by default bitcmp(r, 333)

--> log2(1e100)
 ans  =
   332.19280948873625903

--> r = bitcmp(1e100, 333)
 r  =
   7.498005798264093D+99

--> bitcmp(1e100)  // bitnum = int(log2(x)) + 1 is used by default
 ans  =
   7.498005798264093D+99

--> bitcmp(r, 333)
 ans  =
   1.00000000000000D+100

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

• bitxor — bitwise logical XOR between element-wise integers of 2 arrays
• bitget — Извлекает из целых чисел биты по указанным индексам
• минус — (-) оператор вычитания; меняет знак

История