Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Please login or create an account
Change language to: English - Français - Português - 日本語 -
Справка Scilab >> Основные функции > Побитовые операции > bitcmp

bitcmp

побитовое дополнение целых чисел

Синтаксис

y = bitcmp(x)
y = bitcmp(x, bitnum)

Аргументы

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 — Извлекает из целых чисел биты по указанным индексам
  • минус — (-) оператор вычитания; меняет знак

История

ВерсияОписание
6.1.1
  • Расширение до 64-битных целых чисел.
  • Расширение до всех знаковых целых чисел.
  • Десятичные положительные целые числа > 2^52 вплоть до 2^1024 = number_properties("huge") теперь могут быть обработаны с bitnum вплоть до 1024 вместо 52.
  • bitnum теперь необязательно как и входные десятичные целые числа. Оно на самом деле может быть массивом.
Scilab Enterprises
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors
Last updated:
Tue Jul 20 11:21:22 CEST 2021