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 >> Основные функции > Побитовые операции > bitset

bitset

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

Синтаксис

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

Параметры

x

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

bitInd

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

typeof(x)bitmax..typeof(x)bitmax
int87 uint88
int1615uint1616
int3231uint3232
int6463uint1664
decimal1024

  • Если размер 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 — преобразование из десятичной системы счисления в двоичную

История

VersionDescription
5.0 Функция введена.
6.1.0
  • Теперь поддерживаются 64-битные целые числа.
  • Добавлена поддержка для положительных знаковых целых чисел.
  • Для десятичных чисел биты от №53 до №1024 теперь могут быть должным образом установлены.
  • Для каждого входного элемента теперь несколько битов могут быть установлены одновременно.
  • Входные аргументы теперь могут смешивать массивы и скаляры вместо обязательных поэлементных массивов.
Scilab Enterprises
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors
Last updated:
Tue Feb 25 08:54:54 CET 2020