-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Integer logarithms.
--   
--   Math.NumberTheory.Logarithms and
--   Math.NumberTheory.Powers.Integer from the arithmoi package.
--   
--   Also provides GHC.Integer.Logarithms.Compat and
--   Math.NumberTheory.Power.Natural modules, as well as some
--   additional functions in migrated modules.
@package integer-logarithms
@version 1.0.4

-- | Low level stuff for integer logarithms.
module GHC.Integer.Logarithms.Compat
integerLogBase# :: Integer -> Integer -> Int#
integerLog2# :: Integer -> Int#
wordLog2# :: Word# -> Int#

-- | Integer Logarithms. For efficiency, the internal representation of
--   Integers from integer-gmp is used.
module Math.NumberTheory.Logarithms

-- | Calculate the integer logarithm for an arbitrary base. The base must
--   be greater than 1, the second argument, the number whose logarithm is
--   sought, must be positive, otherwise an error is thrown. If base ==
--   2, the specialised version is called, which is more efficient
--   than the general algorithm.
--   
--   Satisfies:
--   
--   
--   base ^ integerLogBase base m <= m < base ^ (integerLogBase base m + 1)
--   
--   
--   for base > 1 and m > 0.
integerLogBase :: Integer -> Integer -> Int

-- | Calculate the integer logarithm of an Integer to base 2. The
--   argument must be positive, otherwise an error is thrown.
integerLog2 :: Integer -> Int

-- | Calculate the integer logarithm of an Integer to base 10. The
--   argument must be positive, otherwise an error is thrown.
integerLog10 :: Integer -> Int

-- | Cacluate the integer logarithm for an arbitrary base. The base must be
--   greater than 1, the second argument, the number whose logarithm is
--   sought, must be positive, otherwise an error is thrown. If base ==
--   2, the specialised version is called, which is more efficient
--   than the general algorithm.
--   
--   Satisfies:
--   
--   
--   base ^ integerLogBase base m <= m < base ^ (integerLogBase base m + 1)
--   
--   
--   for base > 1 and m > 0.
naturalLogBase :: Natural -> Natural -> Int

-- | Calculate the natural logarithm of an Natural to base 2. The
--   argument must be non-zero, otherwise an error is thrown.
naturalLog2 :: Natural -> Int

-- | Calculate the integer logarithm of an Integer to base 10. The
--   argument must be not zero, otherwise an error is thrown.
naturalLog10 :: Natural -> Int

-- | Calculate the integer logarithm of an Int to base 2. The
--   argument must be positive, otherwise an error is thrown.
intLog2 :: Int -> Int

-- | Calculate the integer logarithm of a Word to base 2. The
--   argument must be positive, otherwise an error is thrown.
wordLog2 :: Word -> Int

-- | Same as integerLogBase, but without checks, saves a little time
--   when called often for known good input.
integerLogBase' :: Integer -> Integer -> Int

-- | Same as integerLog2, but without checks, saves a little time
--   when called often for known good input.
integerLog2' :: Integer -> Int

-- | Same as integerLog10, but without a check for a positive
--   argument. Saves a little time when called often for known good input.
integerLog10' :: Integer -> Int

-- | Same as intLog2, but without checks, saves a little time when
--   called often for known good input.
intLog2' :: Int -> Int

-- | Same as wordLog2, but without checks, saves a little time when
--   called often for known good input.
wordLog2' :: Word -> Int

-- | Potentially faster power function for Integer base and
--   Int or Word exponent.

-- | Deprecated: It is no faster than (^)
module Math.NumberTheory.Powers.Integer

-- | Power of an Integer by the left-to-right repeated squaring
--   algorithm. This needs two multiplications in each step while the
--   right-to-left algorithm needs only one multiplication for 0-bits, but
--   here the two factors always have approximately the same size, which on
--   average gains a bit when the result is large.
--   
--   For small results, it is unlikely to be any faster than (^),
--   quite possibly slower (though the difference shouldn't be large), and
--   for exponents with few bits set, the same holds. But for exponents
--   with many bits set, the speedup can be significant.
--   
--   Warning: No check for the negativity of the exponent is
--   performed, a negative exponent is interpreted as a large positive
--   exponent.
integerPower :: Integer -> Int -> Integer

-- | Same as integerPower, but for exponents of type Word.
integerWordPower :: Integer -> Word -> Integer

-- | Potentially faster power function for Natural base and
--   Int or Word exponent.

-- | Deprecated: It is no faster than (^)
module Math.NumberTheory.Powers.Natural

-- | Power of an Natural by the left-to-right repeated squaring
--   algorithm. This needs two multiplications in each step while the
--   right-to-left algorithm needs only one multiplication for 0-bits, but
--   here the two factors always have approximately the same size, which on
--   average gains a bit when the result is large.
--   
--   For small results, it is unlikely to be any faster than (^),
--   quite possibly slower (though the difference shouldn't be large), and
--   for exponents with few bits set, the same holds. But for exponents
--   with many bits set, the speedup can be significant.
--   
--   Warning: No check for the negativity of the exponent is
--   performed, a negative exponent is interpreted as a large positive
--   exponent.
naturalPower :: Natural -> Int -> Natural

-- | Same as naturalPower, but for exponents of type Word.
naturalWordPower :: Natural -> Word -> Natural
