bitset

Параметры

x

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

bitInd

Индексы битов, которые должны быть установлены: массив положительных десятичных или кодированных целых чисел (поддерживаются все типы целых чисел), чьи значения находятся в интервале [1 bitmax], где bitmax - это максимальный индекс битов для типа x. Бит №1 - самый младший (2⁰).

typeof(x)	bitmax	..	typeof(x)	bitmax
int8	7		uint8	8
int16	15		uint16	16
int32	31		uint32	32
int64	63		uint16	64
decimal	1024

• Если размер bitInd совпадает с размером x, то выполняется поэлементная обработка: для каждого индекса i в x бит №bitInd(i) устанавливается в x(i).

• Если x имеет N размерностей и первые N размерностей bitInd совпадают с размерностями x, и bitInd имеет N+1 размерностей, то для каждого x(i1,i2,..iN) будут установлены все его биты №bitInd(i1,i2,..iN, :).

• В противном случае: bitInd должен быть вектором длиной<= bitmax. Тогда все биты, указанные в bitInd, устанавливаются во всех элементах x.

bitVal

Массив значений 0 или 1 в виде десятичных или кодированных целых чисел (поддерживаются все типы целых чисел): значения в которые соответствующие биты должны быть установлены. bitVal либо имеет размер bitInd, либо является скаляром (тогда одно и то же значение используется для всех битов).

y

Обработанный x с тем же размером и типом данных (и типом целых чисел), что и x.

Описание

Устанавливает биты x, указанные с помощью bitInd либо в 1, либо в указанные значения bitVal.

Примеры

Установка одного или нескольких битов в скаляре:

n = int8(20);
ns = bitset(n, [1 3 6]) // Установка битов №1 №3 №6 (в 1, по умолчанию)
bitget([n ns], 1:7)     // содержимое битов до/после установки

ns = bitset(n, [1 3 6], [1 0 1]) // в явно указанные значения битов
bitget([n ns], 1:7)

--> n = int8(20);
--> ns = bitset(n, [1 3 6]) // Установка битов №1 №3 №6 (в 1, по умолчанию)
 ns  =
  53

--> bitget([n ns], 1:7)     // содержимое битов до/после установки
 ans  =
  0  0  1  0  1  0  0
  1  0  1  0  1  1  0

--> ns = bitset(n, [1 3 6], [1 0 1]) // в явно указанные значения битов
 ns  =
  49

--> bitget([n ns], 1:7)
 ans  =
  0  0  1  0  1  0  0
  1  0  0  0  1  1  0

Установка одних и тех же битов в одно и тоже значение во всех входных элементах:

n = uint16([28  59; 23  19])
ns = bitset(n, [3 5], [1 0])
bitget(n, 1:8)
bitget(ns,1:8)

--> n = uint16([28  59; 23  19])
 n  =
  28  59
  23  19

--> ns = bitset(n, [3 5], [1 0])
 ns  =
  12  47
   7   7

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

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

Установка отдельного бита в каждом элементе массива по индексу бита в зависимости от элемента, поэлементно:

n = uint16([94 78 ; 6 19])
ns = bitset(n, [2 4 ; 3 5], 0)            // в одно и то же значение бита 0
ns2 = bitset(n, [1 3 ; 2 4], [1 0 ; 0 1]) // в соответствующие значения битов
// Анализ:
bitget(ns, 1:8)  // #[2 3 4 5] устанавливаются в 0
bitget(n, 1:8)   // вход
bitget(ns2, 1:8) // #[1 2 3 4] устанавливаются в [1 0 0 1]

--> n = uint16([94 78 ; 6 19])
 n  =
  94  78
   6  19

--> ns = bitset(n, [2 4 ; 3 5], 0)            // в одно и то же значение бита 0
 ns  =
  92  70
   2   3

--> ns2 = bitset(n, [1 3 ; 2 4], [1 0 ; 0 1]) // в соответствующие значения битов
 ns2  =
  95  74
   4  27

--> // Анализ:
--> bitget(ns, 1:8)    // #[2 3 4 5] устанавливаются в 0
 ans  =
  0  0  1  1  1  0  1  0
  0  1  0  0  0  0  0  0
  0  1  1  0  0  0  1  0
  1  1  0  0  0  0  0  0

--> bitget(n, 1:8)     // вход
 ans  =
  0  1  1  1  1  0  1  0
  0  1  1  0  0  0  0  0
  0  1  1  1  0  0  1  0
  1  1  0  0  1  0  0  0

--> bitget(ns2, 1:8)    // #[1 2 3 4] устанавливаются в [1 0 0 1]
 ans  =
  1  1  1  1  1  0  1  0
  0  0  1  0  0  0  0  0
  0  1  0  1  0  0  1  0
  1  1  0  1  1  0  0  0

Установка нескольких битов в каждом входном элементе, поэлементно:

// Биты устанавливаются в 1:
n = int64([6 49 71]);
bitInd = cat(3, [1 3 5], [2 4 6])
ns = bitset(n, bitInd)
bitget(n, 1:8)
bitget(ns, 1:8)

--> n = int64([6 49 71]);
--> bitInd = cat(3, [1 3 5], [2 4 6])
 bitInd  =
(:,:,1)
   1.   3.   5.
(:,:,2)
   2.   4.   6.

--> ns = bitset(n, bitInd)
 ns  =
  7  61  119

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

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

// Биты устанавливаются в соответствующие значения:
n = uint64([6 49 71]);
bitInd = cat(3, [1 3 5], [2 4 6])
bitVal = cat(3, [1 1 1], [0 0 0])
n
ns = bitset(n, bitInd, bitVal)
bitget(n, 1:8)
bitget(ns, 1:8)

--> bitInd = cat(3, [1 3 5], [2 4 6])
 bitInd  =
(:,:,1)
   1.   3.   5.
(:,:,2)
   2.   4.   6.

--> bitVal = cat(3, [1 1 1], [0 0 0])
 bitVal  =
(:,:,1)
   1.   1.   1.
(:,:,2)
   0.   0.   0.

--> n
 n  =
  6  49  71

--> ns = bitset(n, bitInd, bitVal)
 ns  =
  5  53  87

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

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

Установка битов в десятичных числах, даже для больших чисел:

n = [0 1.2345e20];
showBits =     [1 10 40 50 60 61 62 63 64 65 66];
ns = bitset(n, [  10 40       61    63 64 65   ], ..
               [   1  0        1     1  0  1   ])
[bitget(n, showBits); showBits ; bitget(ns, showBits)] // [перед ; № бита ; после]
// биты в №<(65|66 - 53) являются неизвестными

--> ns = bitset(n, [  10 40       61    63 64 65   ], ..
  >                [   1  0        1     1  0  1   ])
 ns  =
   2.421D+19   1.373D+20

--> [bitget(n, showBits); showBits ; bitget(ns, showBits)] // [перед ; № бита ; после]
 ans  =
   0.    0.    0.    0.    0.    0.    0.    0.    0.    0.    0.
   Nan   Nan   1.    1.    0.    1.    1.    0.    1.    0.    1.
   1.    10.   40.   50.   60.   61.   62.   63.   64.   65.   66.
   Nan   Nan   0.    0.    0.    1.    0.    1.    0.    1.    0.
   Nan   Nan   0.    1.    0.    1.    1.    1.    0.    1.    1.

--> // биты в №<(65|66 - 53) являются неизвестными

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

• bitget — Извлекает из целых чисел биты по указанным индексам
• |, || — Binary OR between integers. Logical OR over/between booleans and numbers
• &, && — Binary AND between integers. Logical AND over/between booleans and numbers
• or — logical OR over the elements of a boolean or numerical array
• and — logical AND between the elements of a boolean or numerical array
• bin2dec — преобразование из двоичной системы счисления в десятичную
• dec2bin — преобразование из десятичной системы счисления в двоичную

История