Spec-Zone.ru › Haskell 7

Data.Bits

Авторские права (c) Университет Глазго 2001
Лицензия BSD-стиль (см. файл libraries/base/LICENSE)
Поддержка libraries@haskell.org
Стабильность экспериментальная
Переносимость переносимая
Safe Haskell Надежная
Язык Haskell2010

Описание

Этот модуль определяет побитовые операции для целых чисел со знаком и без знака. Экземпляры класса Bits для типов Int и Integer доступны из этого модуля, а экземпляры для явно размеченных целочисленных типов доступны из модулей Data.Int и Data.Word.

class Eq a => Bits a where Исходный код

Класс Bits определяет побитовые операции над целочисленными типами.

  • Биты нумеруются с 0, причём бит 0 — это младший бит.

Минимальное полное определение

(.&.), (.|.), xor, complement, (shift | shiftL, shiftR), (rotate | rotateL, rotateR), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount

Методы

(.&.) :: a -> a -> a infixl 7 Source

Побитовое "и"

(.|.) :: a -> a -> a infixl 5 Source

Побитовое "или"

xor :: a -> a -> a infixl 6 Source

Побитовое "исключающее или"

complement :: a -> a Source

Инвертирует все биты аргумента

shift :: a -> Int -> a infixl 8 Source

shift x i сдвигает x влево на i бит, если i положительно, или вправо на -i бит в противном случае. Сдвиги вправо выполняют расширение знака для типов чисел со знаком; т.е. они заполняют старшие биты единицами, если x отрицательно, и нулями в противном случае.

Экземпляр может определить либо этот унифицированный shift метод, либо shiftL и shiftR, в зависимости от того, что более удобно для рассматриваемого типа.

rotate :: a -> Int -> a infixl 8 Source

rotate x i вращает x влево на i бит, если i положительно, или вправо на -i бит в противном случае.

Для неограниченных типов, таких как Integer, rotate эквивалентно shift.

Экземпляр может определить либо этот унифицированный rotate метод, либо rotateL и rotateR, в зависимости от того, что более удобно для рассматриваемого типа.

zeroBits :: a Source

zeroBits - это значение со всеми сброшенными битами.

Следующие законы должны соблюдаться (для всех допустимых битовых индексов n):

  • clearBit zeroBits n == zeroBits
  • setBit   zeroBits n == bit n
  • testBit  zeroBits n == False
  • popCount zeroBits   == 0

Этот метод использует clearBit (bit 0) 0 в качестве реализации по умолчанию (которая должна быть эквивалентна zeroBits для типов, которые имеют 0-й бит).

С момента: 4.7.0.0

bit :: Int -> a Source

bit i - это значение с i-м битом установленным и всеми другими битами сброшенными.

Может быть реализовано с использованием bitDefault если a также является экземпляром Num.

См. также zeroBits.

setBit :: a -> Int -> a Source

x `setBit` i эквивалентно x .|. bit i

clearBit :: a -> Int -> a Source

x `clearBit` i эквивалентно x .&. complement (bit i)

complementBit :: a -> Int -> a Source

x `complementBit` i эквивалентно x `xor` bit i

testBit :: a -> Int -> Bool Source

Возвращает True если n-й бит аргумента равен 1

Может быть реализовано с использованием testBitDefault если a также является экземпляром Num.

bitSizeMaybe :: a -> Maybe Int Source

Возвращает количество бит в типе аргумента. Фактическое значение аргумента игнорируется. Возвращает Nothing для типов, не имеющих фиксированного размера в битах, таких как Integer.

С момента: 4.7.0.0

bitSize :: a -> Int Source

Устарело: Используйте bitSizeMaybe или finiteBitSize вместо этого

Возвращает количество бит в типе аргумента. Фактическое значение аргумента игнорируется. Функция bitSize не определена для типов, не имеющих фиксированного размера в битах, таких как Integer.

isSigned :: a -> Bool Source

Возвращает True если аргумент является типом со знаком. Фактическое значение аргумента игнорируется

shiftL :: a -> Int -> a infixl 8 Source

Сдвигает аргумент влево на указанное количество бит (которое должно быть неотрицательным).

Экземпляр может определить либо этот и shiftR методы, либо унифицированный shift метод, в зависимости от того, что более удобно для рассматриваемого типа.

unsafeShiftL :: a -> Int -> a Source

Сдвигает аргумент влево на указанное количество бит. Результат неопределен для отрицательных значений сдвига и значений сдвига, больших или равных bitSize.

По умолчанию эквивалентно shiftL если не определено явно экземпляром.

С момента: 4.5.0.0

shiftR :: a -> Int -> a infixl 8 Source

Сдвигает первый аргумент вправо на указанное количество бит. Результат неопределен для отрицательных значений сдвига и значений сдвига, больших или равных bitSize.

Сдвиги вправо выполняют расширение знака для типов чисел со знаком; т.е. они заполняют старшие биты единицами, если x отрицательно, и нулями в противном случае.

Экземпляр может определить либо этот и shiftL методы, либо унифицированный shift метод, в зависимости от того, что более удобно для рассматриваемого типа.

unsafeShiftR :: a -> Int -> a Source

Сдвигает первый аргумент вправо на указанное количество бит, которое должно быть неотрицательным и меньше количества бит в типе.

Сдвиги вправо выполняют расширение знака для типов чисел со знаком; т.е. они заполняют старшие биты единицами, если x отрицательно, и нулями в противном случае.

По умолчанию эквивалентно shiftR если не определено явно экземпляром.

С момента: 4.5.0.0

rotateL :: a -> Int -> a infixl 8 Source

Вращает аргумент влево на указанное количество бит (которое должно быть неотрицательным).

Экземпляр может определить либо этот и rotateR методы, либо унифицированный rotate метод, в зависимости от того, что более удобно для рассматриваемого типа.

rotateR :: a -> Int -> a infixl 8 Source

Вращает аргумент вправо на указанное количество бит (которое должно быть неотрицательным).

Экземпляр может определить либо этот и rotateL методы, либо унифицированный rotate метод, в зависимости от того, что более удобно для рассматриваемого типа.

popCount :: a -> Int Source

Возвращает количество установленных бит в аргументе. Это число известно как количество элементов или вес Хэмминга.

Может быть реализовано с использованием popCountDefault если a также является экземпляром Num.

С момента: 4.5.0.0

Примеры реализации

Bits Bool
Bits Int
Bits Int8
Bits Int16
Bits Int32
Bits Int64
Bits Целое число
Bits Word
Bits Word8
Bits Word16
Bits Word32
Bits Word64
Bits CUIntMax
Bits CIntMax
Bits CUIntPtr
Bits CIntPtr
Bits CSigAtomic
Bits CWchar
Bits CSize
Bits CPtrdiff
Bits CULLong
Bits CLLong
Bits CULong
Bits CLong
Bits CUInt
Bits CInt
Bits CUShort
Bits CShort
Bits CUChar
Bits CSChar
Bits CChar
Bits IntPtr
Bits WordPtr
Bits Fd
Bits CRLim
Bits CTcflag
Bits CUid
Bits CNlink
Bits CGid
Bits CSsize
Bits CPid
Bits COff
Bits CMode
Bits CIno
Bits CDev
Bits Натуральное число

класс Bits b => FiniteBits b где Источник

Класс FiniteBits обозначает типы с конечным, фиксированным числом битов.

С версии: 4.7.0.0

Минимальное полное определение

finiteBitSize

Методы

finiteBitSize :: b -> Int Источник

Возвращает число битов в типе аргумента. Фактическое значение аргумента игнорируется. Кроме того, finiteBitSize является полным, в отличие от устаревшей функции bitSize, которую она заменяет.

finiteBitSize = bitSize
bitSizeMaybe = Just . finiteBitSize

С версии: 4.7.0.0

countLeadingZeros :: b -> Int Источник

Подсчитывает количество нулевых битов, предшествующих наиболее значимому установленному биту.

countLeadingZeros (zeroBits :: a) = finiteBitSize (zeroBits :: a)

countLeadingZeros может быть использовано для вычисления логарифма по основанию 2:

logBase2 x = finiteBitSize x - 1 - countLeadingZeros x

Примечание: Реализация по умолчанию для этого метода преднамеренно простая. Однако реализации для примитивных целочисленных типов используют инструкции процессора.

С версии: 4.8.0.0

countTrailingZeros :: b -> Int Источник

Подсчитывает количество нулевых битов, следующих за наименее значимым установленным битом.

countTrailingZeros (zeroBits :: a) = finiteBitSize (zeroBits :: a)
countTrailingZeros . negate = countTrailingZeros

Сопутствующая операция find-first-set может быть выражена через countTrailingZeros следующим образом:

findFirstSet x = 1 + countTrailingZeros x

Примечание: Реализация по умолчанию для этого метода преднамеренно простая. Однако реализации для примитивных целочисленных типов используют инструкции процессора.

С версии: 4.8.0.0

Экземпляры

FiniteBits Bool
FiniteBits Int
FiniteBits Int8
FiniteBits Int16
FiniteBits Int32
FiniteBits Int64
FiniteBits Word
FiniteBits Word8
FiniteBits Word16
FiniteBits Word32
FiniteBits Word64
FiniteBits CUIntMax
FiniteBits CIntMax
FiniteBits CUIntPtr
FiniteBits CIntPtr
FiniteBits CSigAtomic
FiniteBits CWchar
FiniteBits CSize
FiniteBits CPtrdiff
FiniteBits CULLong
FiniteBits CLLong
FiniteBits CULong
FiniteBits CLong
FiniteBits CUInt
FiniteBits CInt
FiniteBits CUShort
FiniteBits CShort
FiniteBits CUChar
FiniteBits CSChar
FiniteBits CChar
FiniteBits IntPtr
FiniteBits WordPtr
FiniteBits Fd
FiniteBits CRLim
FiniteBits CTcflag
FiniteBits CUid
FiniteBits CNlink
FiniteBits CGid
FiniteBits CSsize
FiniteBits CPid
FiniteBits COff
FiniteBits CMode
FiniteBits CIno
FiniteBits CDev

bitDefault :: (Bits a, Num a) => Int -> a Source

Реализация по умолчанию для bit.

Обратите внимание, что: bitDefault i = 1 shiftL i

Since: 4.6.0.0

testBitDefault :: (Bits a, Num a) => a -> Int -> Bool Source

Реализация по умолчанию для testBit.

Обратите внимание, что: testBitDefault x i = (x .&. bit i) /= 0

Since: 4.6.0.0

popCountDefault :: (Bits a, Num a) => a -> Int Source

Реализация по умолчанию для popCount.

Эта реализация преднамеренно наивна. Ожидается, что экземпляры предоставят оптимизированную реализацию для своего размера.

Since: 4.6.0.0

toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b Source

Попытка преобразовать тип Integral a в тип Integral b с использованием размера типов, измеренного методами Bits.

Более простая версия этой функции:

toIntegral :: (Integral a, Integral b) => a -> Maybe b
toIntegral x
  | toInteger x == y = Just (fromInteger y)
  | otherwise        = Nothing
  where
    y = toInteger x

Эта версия требует прохождения через Integer, что может быть неэффективно. Однако, toIntegralSized оптимизирован, чтобы позволить GHC статически определять относительные размеры типов (измеренные с помощью bitSizeMaybe и isSigned) и избежать прохождения через Integer для многих типов. (Реализация использует fromIntegral, который сам по себе оптимизирован с правилами для типов base, но может проходить через Integer для некоторых пар типов.)

Since: 4.8.0.0

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/7.10.3/docs/html/libraries/base-4.8.2.0/Data-Bits.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API