bitset устанавливает в целых числах биты по указанным индексам

## Синтаксис

                y = bitset(x, bitInd)
                y = bitset(x, bitInd, bitVal)

## Параметры

x

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

bitInd

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

  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
- |, ||
- &, &&
- or
- and
- bin2dec
- dec2bin

## История

5.0 Функция введена.
6.1.0

- Теперь поддерживаются 64-битные целые числа.
- Добавлена поддержка для положительных знаковых целых чисел.
- Для десятичных чисел биты от №53 до №1024 теперь могут быть должным образом установлены.
- Для каждого входного элемента теперь несколько битов могут быть установлены одновременно.
- Входные аргументы теперь могут смешивать массивы и скаляры вместо обязательных поэлементных массивов.