Crypto.Lol.Cyclotomic.Tensor.CTensor

Wrapper for a C++ implementation of the Tensor interface.

Documentation

data CT m r

An implementation of Tensor backed by C++ code.

Instances

Tensor CT

Associated Types

type TElt (CT :: Factored -> * -> *) r :: Constraint

Methods

entailIndexT :: Tagged * (CT m r) (Fact m :- (Applicative (CT m), Traversable (CT m)))

entailEqT :: Tagged * (CT m r) ((Eq r, Fact m, TElt CT r) :- Eq (CT m r))

entailZTT :: Tagged * (CT m r) ((ZeroTestable r, Fact m, TElt CT r) :- ZeroTestable (CT m r))

entailNFDataT :: Tagged * (CT m r) ((NFData r, Fact m, TElt CT r) :- NFData (CT m r))

entailRandomT :: Tagged * (CT m r) ((Random r, Fact m, TElt CT r) :- Random (CT m r))

entailShowT :: Tagged * (CT m r) ((Show r, Fact m, TElt CT r) :- Show (CT m r))

entailModuleT :: Tagged * (GF k fp d, CT m fp) ((GFCtx k fp d, Fact m, TElt CT fp) :- Module (GF k fp d) (CT m fp))

scalarPow :: (Additive r, Fact m, TElt CT r) => r -> CT m r

l :: (Additive r, Fact m, TElt CT r) => CT m r -> CT m r

lInv :: (Additive r, Fact m, TElt CT r) => CT m r -> CT m r

mulGPow :: (Ring r, Fact m, TElt CT r) => CT m r -> CT m r

mulGDec :: (Ring r, Fact m, TElt CT r) => CT m r -> CT m r

divGPow :: (ZeroTestable r, IntegralDomain r, Fact m, TElt CT r) => CT m r -> Maybe (CT m r)

divGDec :: (ZeroTestable r, IntegralDomain r, Fact m, TElt CT r) => CT m r -> Maybe (CT m r)

crtFuncs :: (CRTrans mon r, Fact m, TElt CT r) => mon (r -> CT m r, CT m r -> CT m r, CT m r -> CT m r, CT m r -> CT m r, CT m r -> CT m r)

tGaussianDec :: (OrdFloat q, Random q, TElt CT q, ToRational v, Fact m, MonadRandom rnd) => v -> rnd (CT m q)

gSqNormDec :: (Ring r, Fact m, TElt CT r) => CT m r -> r

twacePowDec :: (Ring r, Divides m m', TElt CT r) => CT m' r -> CT m r

embedPow :: (Additive r, Divides m m', TElt CT r) => CT m r -> CT m' r

embedDec :: (Additive r, Divides m m', TElt CT r) => CT m r -> CT m' r

crtExtFuncs :: (CRTrans mon r, Divides m m', TElt CT r) => mon (CT m' r -> CT m r, CT m r -> CT m' r)

coeffs :: (Ring r, Divides m m', TElt CT r) => CT m' r -> [CT m r]

powBasisPow :: (Ring r, TElt CT r, Divides m m') => Tagged Factored m [CT m' r]

crtSetDec :: (Divides m m', PrimeField fp, Coprime (PToF (CharOf PrimeBin fp)) m', TElt CT fp) => Tagged Factored m [CT m' fp]

fmapT :: (Fact m, TElt CT a, TElt CT b) => (a -> b) -> CT m a -> CT m b

zipWithT :: (Fact m, TElt CT a, TElt CT b, TElt CT c) => (a -> b -> c) -> CT m a -> CT m b -> CT m c

unzipT :: (Fact m, TElt CT (a, b), TElt CT a, TElt CT b) => CT m (a, b) -> (CT m a, CT m b)

Fact m => Functor (CT m)

Methods

fmap :: (a -> b) -> CT m a -> CT m b

(<$) :: a -> CT m b -> CT m a

Fact m => Applicative (CT m)

Methods

pure :: a -> CT m a

(<*>) :: CT m (a -> b) -> CT m a -> CT m b

(*>) :: CT m a -> CT m b -> CT m b

(<*) :: CT m a -> CT m b -> CT m a

Fact m => Foldable (CT m)

Methods

fold :: Monoid m => CT m m -> m

foldMap :: Monoid m => (a -> m) -> CT m a -> m

foldr :: (a -> b -> b) -> b -> CT m a -> b

foldr' :: (a -> b -> b) -> b -> CT m a -> b

foldl :: (b -> a -> b) -> b -> CT m a -> b

foldl' :: (b -> a -> b) -> b -> CT m a -> b

foldr1 :: (a -> a -> a) -> CT m a -> a

foldl1 :: (a -> a -> a) -> CT m a -> a

toList :: CT m a -> [a]

null :: CT m a -> Bool

length :: CT m a -> Int

elem :: Eq a => a -> CT m a -> Bool

maximum :: Ord a => CT m a -> a

minimum :: Ord a => CT m a -> a

sum :: Num a => CT m a -> a

product :: Num a => CT m a -> a

Fact m => Traversable (CT m)

Methods

traverse :: Applicative f => (a -> f b) -> CT m a -> f (CT m b)

sequenceA :: Applicative f => CT m (f a) -> f (CT m a)

mapM :: Monad m => (a -> m b) -> CT m a -> m (CT m b)

sequence :: Monad m => CT m (m a) -> m (CT m a)

Eq r => Eq (CT m r)

Methods

(==) :: CT m r -> CT m r -> Bool

(/=) :: CT m r -> CT m r -> Bool

Show r => Show (CT m r)

Methods

showsPrec :: Int -> CT m r -> ShowS

show :: CT m r -> String

showList :: [CT m r] -> ShowS

(Storable r, Random (CT' m r)) => Random (CT m r)

Methods

randomR :: RandomGen g => (CT m r, CT m r) -> g -> (CT m r, g)

random :: RandomGen g => g -> (CT m r, g)

randomRs :: RandomGen g => (CT m r, CT m r) -> g -> [CT m r]

randoms :: RandomGen g => g -> [CT m r]

randomRIO :: (CT m r, CT m r) -> IO (CT m r)

randomIO :: IO (CT m r)

(Storable r, Arbitrary (CT' m r)) => Arbitrary (CT m r)

Methods

arbitrary :: Gen (CT m r)

shrink :: CT m r -> [CT m r]

NFData r => NFData (CT m r)

Methods

rnf :: CT m r -> ()

(ZeroTestable r, Storable r) => C (CT m r)

Methods

isZero :: CT m r -> Bool

(Additive r, Storable r, Fact m) => C (CT m r)

Methods

zero :: CT m r

(+) :: CT m r -> CT m r -> CT m r

(-) :: CT m r -> CT m r -> CT m r

negate :: CT m r -> CT m r

(Fact m, Reflects k q Double) => Protoable (CT m (RRq k q Double))

Associated Types

type ProtoType (CT m (RRq k q Double)) :: *

Methods

toProto :: CT m (RRq k q Double) -> ProtoType (CT m (RRq k q Double))

fromProto :: MonadError String m => ProtoType (CT m (RRq k q Double)) -> m (CT m (RRq k q Double))

(Fact m, Reflects k q Int64) => Protoable (CT m (ZqBasic k q Int64))

Associated Types

type ProtoType (CT m (ZqBasic k q Int64)) :: *

Methods

toProto :: CT m (ZqBasic k q Int64) -> ProtoType (CT m (ZqBasic k q Int64))

fromProto :: MonadError String m => ProtoType (CT m (ZqBasic k q Int64)) -> m (CT m (ZqBasic k q Int64))

(GFCtx k fp d, Fact m, Additive (CT m fp)) => C (GF k fp d) (CT m fp)

Methods

(*>) :: GF k fp d -> CT m fp -> CT m fp

type TElt CT r

type TElt CT r

type ProtoType (CT m (RRq k q Double))

type ProtoType (CT m (RRq k q Double)) = Kq

type ProtoType (CT m (ZqBasic k q Int64))

type ProtoType (CT m (ZqBasic k q Int64)) = Rq