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
- bitget
- минус

## История

6.1.1

- Расширение до 64-битных целых чисел.
- Расширение до всех знаковых целых чисел.
- Десятичные положительные целые числа > 2^52 вплоть до 2^1024 = number_properties("huge") теперь могут быть обработаны с bitnum вплоть до 1024 вместо 52.
- bitnum теперь необязательно как и входные десятичные целые числа. Оно на самом деле может быть массивом.