{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}
-- | Definitions, mostly class instances, needed to make AST a valid
-- carrier for a tensor class algebra (instance) defined
-- in "HordeAd.Core.OpsAst".
-- This algebra permits user programs to be instantiated as AST terms,
-- as well as to be interpreted into AST terms and it also permits derivatives
-- to be expressed as AST terms.
module HordeAd.Core.CarriersAst
  ( AstRaw(..), AstNoVectorize(..), AstNoSimplify(..)
  , astLetFunNoSimplify, sunReplicateScal, sunReplicate1, sunReplicateN
  ) where

import Prelude hiding (foldl')

import Data.Int (Int64)
import Data.Type.Equality (testEquality, (:~:) (Refl))
import Foreign.C (CInt)
import Type.Reflection (typeRep)

import Data.Array.Nested (type (++))
import Data.Array.Nested qualified as Nested
import Data.Array.Nested.Convert (withShsFromShR, withShsFromShX)
import Data.Array.Nested.Mixed qualified as Mixed
import Data.Array.Nested.Mixed.Shape
import Data.Array.Nested.Shaped.Shape

import HordeAd.Core.Ast
import HordeAd.Core.AstFreshId
import HordeAd.Core.AstTools
import HordeAd.Core.CarriersConcrete
import HordeAd.Core.ConvertTensor
import HordeAd.Core.OpsConcrete ()
import HordeAd.Core.TensorKind
import HordeAd.Core.Types

-- * Type family instances for AstTensor

type instance PrimalOf (AstTensor ms s) = AstTensor ms PrimalSpan
type instance DualOf (AstTensor ms s) = AstTensor ms DualSpan
type instance ShareOf (AstTensor ms s) = AstRaw s

-- This can't be just HFun, because they need to be vectorized
-- and vectorization applies such functions to the variable from build1
-- and the variable has to be eliminated via vectorization to preserve
-- the closed form of the function. Just applying a Haskell closure
-- to the build1 variable and then duplicating the result of the function
-- would not eliminate the variable and also would likely results
-- in more costly computations. Also, that would prevent simplification
-- of the instances, especially after applied to arguments that are terms.
type instance HFunOf (AstTensor AstMethodLet s) x z = AstHFun s s x z

type instance BoolOf (AstTensor ms s) = AstBool ms


-- * Unlawful numeric instances for AST scalars; they are lawful modulo evaluation

-- These are, unfortunately, required by some numeric instances.
instance Eq (AstTensor ms s y) where
  == :: AstTensor ms s y -> AstTensor ms s y -> Bool
(==) = [Char] -> AstTensor ms s y -> AstTensor ms s y -> Bool
forall a. HasCallStack => [Char] -> a
error [Char]
"Eq is not defined for AST; please use EqH instead"
  /= :: AstTensor ms s y -> AstTensor ms s y -> Bool
(/=) = [Char] -> AstTensor ms s y -> AstTensor ms s y -> Bool
forall a. HasCallStack => [Char] -> a
error [Char]
"Eq is not defined for AST; please use EqH instead"

instance Ord (AstTensor ms s y) where
  <= :: AstTensor ms s y -> AstTensor ms s y -> Bool
(<=) = [Char] -> AstTensor ms s y -> AstTensor ms s y -> Bool
forall a. HasCallStack => [Char] -> a
error [Char]
"Ord is not defined for AST; please use OrdH instead"

-- TODO: perhaps aim for a polynomial normal form? but that requires global
-- inspection of the whole expression
-- TODO: let's aim at SOP (Sum-of-Products) form, just as
-- ghc-typelits-natnormalise does. Also, let's associate to the right
-- and let's push negation down.
--
-- Not considered are rules that would require comparing non-constant terms
-- or that would duplicate a non-constant term, as well as most rules
-- informed by inequalities, expressed via max or min, such as
-- max n (signum (abs x)) | n <= 0 --> signum (abs x).
-- We could use sharing via @tlet@ if terms are duplicated, but it's
-- unclear if the term bloat is worth it and also we'd need to restrict
-- this extended simplification to AstMethodLet.
--
-- | Integer terms need to be simplified, because large ones are sometimes
-- created due to vectorization, e.g., via astTransposeAsGather
-- or astReshapeAsGather and can be a deciding factor in whether
-- the other tensor terms can be simplified in turn.
--
-- The normal form has AstConcreteK, if any, as the first argument
-- of the constructor. No flattening is performed beyond that.
instance (GoodScalar r, AstSpan s)
         => Num (AstTensor ms s (TKScalar r)) where
  AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u + :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
+ AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a -> a
+ AstTensor ms PrimalSpan (TKScalar r)
v
  AstFromDual AstTensor ms DualSpan (TKScalar r)
u + AstFromDual AstTensor ms DualSpan (TKScalar r)
v = AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms DualSpan (TKScalar r)
u AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms DualSpan (TKScalar r)
forall a. Num a => a -> a -> a
+ AstTensor ms DualSpan (TKScalar r)
v
  -- TODO: define a pattern synonym that captures the below. Also elsewhere.
  AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
u + AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u
    , FTKS ShS sh
ZSS FullShapeTK x
y <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u))
    , Just (:~:) @TK x x
Refl <- FullShapeTK x -> FullShapeTK x -> Maybe ((:~:) @TK x x)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x FullShapeTK x
y =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s (TKScalar r))
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s a1
u AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a -> a
+ AstTensor ms s a1
AstTensor ms s a1
v
  AstConcreteK r
0 + AstTensor ms s (TKScalar r)
u = AstTensor ms s (TKScalar r)
u
  AstTensor ms s (TKScalar r)
u + AstConcreteK r
0 = AstTensor ms s (TKScalar r)
u
  AstConcreteK r
n + AstConcreteK r
k = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
+ r
r
k)
  AstConcreteK r
n + AstPlusK (AstConcreteK r
k) AstTensor ms s (TKScalar r)
u = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
+ r
r
k) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
+ AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstPlusK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
u + AstConcreteK r
k = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
+ r
r
k) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
+ AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstPlusK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
u + AstPlusK (AstConcreteK r
k) AstTensor ms s (TKScalar r)
v =
    r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
+ r
r
k) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
+ AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v  -- u and v can cancel, but unlikely

  -- Unfortunately, these only fire if the required subterms are at the top
  -- of the reduced term, which happens rarely except in small terms.
  -- We could keep variables at the top, but they'd compete with AstConcreteK.
  AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var) + AstVar AstVarName s (TKScalar r)
var'
    | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' = AstTensor ms s (TKScalar r)
0
  AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var))
    + AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')
    | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' = AstTensor ms s (TKScalar r)
0
  AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var) + AstPlusK (AstVar AstVarName s (TKScalar r)
var') AstTensor ms s (TKScalar r)
u
    | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var))
    + AstPlusK (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')) AstTensor ms s (TKScalar r)
u
    | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstVar AstVarName s (TKScalar r)
var' + AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var)
    | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' = AstTensor ms s (TKScalar r)
0
  AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')
    + AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var))
    | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' = AstTensor ms s (TKScalar r)
0
  AstVar AstVarName s (TKScalar r)
var' + AstPlusK (AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var)) AstTensor ms s (TKScalar r)
u
    | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')
    + AstPlusK (AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var))) AstTensor ms s (TKScalar r)
u
    | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u

  AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var)) (AstConcreteK r
n)
   + AstI2K OpCodeIntegral2
RemOp (AstVar AstVarName s (TKScalar r)
var') (AstConcreteK r
n')
     | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
0
  AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var)))
               (AstConcreteK r
n)
   + AstI2K OpCodeIntegral2
RemOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')) (AstConcreteK r
n')
     | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
0
  AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var)) (AstConcreteK r
n)
   + AstPlusK (AstI2K OpCodeIntegral2
RemOp (AstVar AstVarName s (TKScalar r)
var') (AstConcreteK r
n')) AstTensor ms s (TKScalar r)
u
     | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var)))
               (AstConcreteK r
n)
   + AstPlusK (AstI2K OpCodeIntegral2
RemOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var'))
                            (AstConcreteK r
n')) AstTensor ms s (TKScalar r)
u
     | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstI2K OpCodeIntegral2
RemOp (AstVar AstVarName s (TKScalar r)
var') (AstConcreteK r
n')
   + AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var)) (AstConcreteK r
n)
     | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
0
  AstI2K OpCodeIntegral2
RemOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')) (AstConcreteK r
n')
   + AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var)))
                                   (AstConcreteK r
n)
     | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
0
  AstI2K OpCodeIntegral2
RemOp (AstVar AstVarName s (TKScalar r)
var') (AstConcreteK r
n')
   + AstPlusK (AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstVar AstVarName s (TKScalar r)
var)) (AstConcreteK r
n)) AstTensor ms s (TKScalar r)
u
     | AstVarName s (TKScalar r)
var AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
AstVarName s (TKScalar r)
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstI2K OpCodeIntegral2
RemOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var')) (AstConcreteK r
n')
   + AstPlusK (AstI2K OpCodeIntegral2
RemOp (AstN1K OpCodeNum1
NegateOp (AstConvert TKConversion a1 (TKScalar r)
_ (AstVar AstVarName s a1
var)))
                            (AstConcreteK r
n)) AstTensor ms s (TKScalar r)
u
     | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
var' Bool -> Bool -> Bool
&& r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u

  AstPlusK u :: AstTensor ms s (TKScalar r)
u@AstConcreteK{} AstTensor ms s (TKScalar r)
v + AstTensor ms s (TKScalar r)
w = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u (AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
w)  -- as above
  AstTensor ms s (TKScalar r)
u + v :: AstTensor ms s (TKScalar r)
v@AstConcreteK{} = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
u
  AstTensor ms s (TKScalar r)
u + AstPlusK v :: AstTensor ms s (TKScalar r)
v@AstConcreteK{} AstTensor ms s (TKScalar r)
w = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v (AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w)  -- as above
  AstTensor ms s (TKScalar r)
t1 + AstTensor ms s (TKScalar r)
t2 | AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
t1 AstTensor ms s (TKScalar r)
t2 = AstTensor ms s (TKScalar r)
2 AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
t1
  AstTensor ms s (TKScalar r)
t1 + AstTimesK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
t2 | AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
t1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
t2 = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
+ r
1) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
t1
  AstTimesK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
t2 + AstTensor ms s (TKScalar r)
t1 | AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
t1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
t2 = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
+ r
1) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
t1
  AstTimesK (AstConcreteK r
n1) AstTensor ms s (TKScalar r)
t1 + AstTimesK (AstConcreteK r
n2) AstTensor ms s (TKScalar r)
t2
    | AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
t1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
t2 = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n1 r -> r -> r
forall a. Num a => a -> a -> a
+ r
r
n2) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
t1
  AstTensor ms s (TKScalar r)
u + AstTensor ms s (TKScalar r)
v = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v

  AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u * :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
* AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms PrimalSpan (TKScalar r)
v
  AstFromDual{} * AstFromDual{} = AstTensor ms s (TKScalar r)
0
  AstConcreteK r
0 * AstTensor ms s (TKScalar r)
_ = AstTensor ms s (TKScalar r)
0
  AstTensor ms s (TKScalar r)
_ * AstConcreteK r
0 = AstTensor ms s (TKScalar r)
0
  AstConcreteK r
1 * AstTensor ms s (TKScalar r)
u = AstTensor ms s (TKScalar r)
u
  AstTensor ms s (TKScalar r)
u * AstConcreteK r
1 = AstTensor ms s (TKScalar r)
u
  AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
u * AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u
    , FTKS ShS sh
ZSS FullShapeTK x
y <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u))
    , Just (:~:) @TK x x
Refl <- FullShapeTK x -> FullShapeTK x -> Maybe ((:~:) @TK x x)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x FullShapeTK x
y =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s (TKScalar r))
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s a1
u AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a -> a
* AstTensor ms s a1
AstTensor ms s a1
v
  AstConcreteK r
n * AstConcreteK r
k = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
* r
r
k)
  AstConcreteK r
n * AstTimesK (AstConcreteK r
k) AstTensor ms s (TKScalar r)
u = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
* r
r
k) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstTimesK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
u * AstConcreteK r
k = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
* r
r
k) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  AstTimesK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
u * AstTimesK (AstConcreteK r
k) AstTensor ms s (TKScalar r)
v =
    r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
r
n r -> r -> r
forall a. Num a => a -> a -> a
* r
r
k) AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v  -- u and v can cancel, but unlikely

  u :: AstTensor ms s (TKScalar r)
u@AstConcreteK{} * AstPlusK AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
w = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK (AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v) (AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w)
  AstTimesK u :: AstTensor ms s (TKScalar r)
u@AstConcreteK{} AstTensor ms s (TKScalar r)
x * AstPlusK AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
w =
    AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
x (AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v) (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w))
  AstPlusK AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
w * u :: AstTensor ms s (TKScalar r)
u@AstConcreteK{} = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
u) (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
u)
  AstPlusK AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
w * AstTimesK u :: AstTensor ms s (TKScalar r)
u@AstConcreteK{} AstTensor ms s (TKScalar r)
x =
    AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK (AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u) (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u)) AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
x

  AstN1K OpCodeNum1
NegateOp AstTensor ms s (TKScalar r)
u * AstN1K OpCodeNum1
NegateOp AstTensor ms s (TKScalar r)
v = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v

  {- TODO: these rules increase the number of occurrences of a variable
     and trade multiplication and quotient for an equally problematic remnant,
     so they are disabled until we find a way to profit from them.
  -- With static shapes, the second argument to QuotOp and RemOp
  -- is often a constant, which makes such rules worth including,
  -- since they are likely to fire. To help them fire, we avoid changing
  -- that constant, if possible, e.g., in rules for NegateOp.
  AstConcreteK n * AstI2K QuotOp (AstVar var) (AstConcreteK n')
    | n == n' =
      AstPlusK
        (AstVar var)
        (negate (AstI2K RemOp (AstVar var) (AstConcreteK n)))
  AstTimesK (AstConcreteK n) x * AstI2K QuotOp (AstVar var)
                                               (AstConcreteK n')
    | n == n' =
      AstTimesK
        x
        (AstPlusK
           (AstVar var)
           (negate (AstI2K RemOp (AstVar var) (AstConcreteK n))))
  AstI2K QuotOp (AstVar var) (AstConcreteK n') * AstConcreteK n
    | n == n' =
      AstPlusK
        (AstVar var)
        (negate (AstI2K RemOp (AstVar var) (AstConcreteK n)))
  AstI2K QuotOp (AstVar var)
                (AstConcreteK n') * AstTimesK (AstConcreteK n) x
    | n == n' =
      AstTimesK
        (AstPlusK
           (AstVar var)
           (negate (AstI2K RemOp (AstVar var) (AstConcreteK n))))
        x
  -}

  AstTimesK u :: AstTensor ms s (TKScalar r)
u@AstConcreteK{} AstTensor ms s (TKScalar r)
v * AstTensor ms s (TKScalar r)
w = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u (AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
w)  -- as above
  AstTensor ms s (TKScalar r)
u * v :: AstTensor ms s (TKScalar r)
v@AstConcreteK{} = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
u
  AstTensor ms s (TKScalar r)
u * AstTimesK v :: AstTensor ms s (TKScalar r)
v@AstConcreteK{} AstTensor ms s (TKScalar r)
w = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v (AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w)  -- as above
  AstTensor ms s (TKScalar r)
u * AstTensor ms s (TKScalar r)
v = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v

  negate :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
negate (AstCond AstBool ms
b AstTensor ms s (TKScalar r)
n AstTensor ms s (TKScalar r)
k) = AstBool ms
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing) (b :: AstSpanType).
AstBool a -> AstTensor a b c -> AstTensor a b c -> AstTensor a b c
AstCond AstBool ms
b (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
n) (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
k)
  negate (AstLet AstVarName s y
var AstTensor AstMethodLet s y
n AstTensor AstMethodLet s (TKScalar r)
k) = AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s (TKScalar r)
-> AstTensor AstMethodLet s (TKScalar r)
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s y
var AstTensor AstMethodLet s y
n (AstTensor AstMethodLet s (TKScalar r)
-> AstTensor AstMethodLet s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor AstMethodLet s (TKScalar r)
k)
  negate (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
n) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms PrimalSpan (TKScalar r)
n)
  negate (AstFromDual AstTensor ms DualSpan (TKScalar r)
n) = AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms DualSpan (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms DualSpan (TKScalar r)
n)
  negate (AstPlusK AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v) = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstPlusK (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u) (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v)
  negate (AstTimesK AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v) = AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v
  negate (AstN1K OpCodeNum1
NegateOp AstTensor ms s (TKScalar r)
u) = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  negate (AstN1K OpCodeNum1
SignumOp AstTensor ms s (TKScalar r)
u) = OpCodeNum1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
SignumOp (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u)
  negate (AstI2K OpCodeIntegral2
QuotOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v) = OpCodeIntegral2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstI2K OpCodeIntegral2
QuotOp (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u) AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v
    -- v is likely positive and let's keep it so
  negate (AstI2K OpCodeIntegral2
RemOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v) = OpCodeIntegral2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstI2K OpCodeIntegral2
RemOp (AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u) AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v
    -- v is likely positive and let's keep it so
  negate (AstConcreteK r
n) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r
forall a. Num a => a -> a
negate r
r
n)
  negate (AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
u)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)) =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a
negate AstTensor ms s a1
u)
  negate AstTensor ms s (TKScalar r)
u = OpCodeNum1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
NegateOp AstTensor ms s (TKScalar r)
u
  abs :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
abs (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
n) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a
abs AstTensor ms PrimalSpan (TKScalar r)
n)
  abs (AstFromDual AstTensor ms DualSpan (TKScalar r)
n) = AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms DualSpan (TKScalar r)
forall a. Num a => a -> a
abs AstTensor ms DualSpan (TKScalar r)
n)
  abs (AstConcreteK r
n) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r
forall a. Num a => a -> a
abs r
r
n)
  abs (AstN1K OpCodeNum1
AbsOp AstTensor ms s (TKScalar r)
u) = OpCodeNum1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
AbsOp AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  abs (AstN1K OpCodeNum1
NegateOp AstTensor ms s (TKScalar r)
u) = AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a
abs AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  abs (AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
u)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)) =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a
abs AstTensor ms s a1
u)
  abs AstTensor ms s (TKScalar r)
u = OpCodeNum1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
AbsOp AstTensor ms s (TKScalar r)
u
  signum :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
signum (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
n) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a
signum AstTensor ms PrimalSpan (TKScalar r)
n)
  signum (AstFromDual AstTensor ms DualSpan (TKScalar r)
n) = AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms DualSpan (TKScalar r)
forall a. Num a => a -> a
signum AstTensor ms DualSpan (TKScalar r)
n)
  signum (AstConcreteK r
n) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r
forall a. Num a => a -> a
signum r
r
n)
  signum (AstN1K OpCodeNum1
SignumOp AstTensor ms s (TKScalar r)
u) = OpCodeNum1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
SignumOp AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u
  signum (AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
u)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)) =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a
signum AstTensor ms s a1
u)
  signum AstTensor ms s (TKScalar r)
u = OpCodeNum1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
SignumOp AstTensor ms s (TKScalar r)
u
  fromInteger :: Integer -> AstTensor ms s (TKScalar r)
fromInteger Integer
i = AstTensor ms PrimalSpan (TKScalar r) -> AstTensor ms s (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms PrimalSpan y -> AstTensor ms s y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms PrimalSpan y -> AstTensor ms s y
fromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms s (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (Integer -> r
forall a. Num a => Integer -> a
fromInteger Integer
i)
  {-# SPECIALIZE instance Num (AstTensor ms FullSpan (TKScalar Int64)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms PrimalSpan (TKScalar Int64)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms FullSpan (TKScalar CInt)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms PrimalSpan (TKScalar CInt)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms FullSpan (TKScalar Double)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms PrimalSpan (TKScalar Double)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms FullSpan (TKScalar Float)) #-}
  {-# SPECIALIZE instance Num (AstTensor ms PrimalSpan (TKScalar Float)) #-}

-- An approximation. False doesn't imply terms have different semantics,
-- but True implies they have equal semantics.
eqK :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK :: forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK (AstVar AstVarName s (TKScalar r)
var1) (AstVar AstVarName s (TKScalar r)
var2) = AstVarName s (TKScalar r)
var1 AstVarName s (TKScalar r) -> AstVarName s (TKScalar r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKScalar r)
var2
eqK (AstLet @_ @_ @s1 AstVarName s y
var1 AstTensor AstMethodLet s y
u1 AstTensor AstMethodLet s (TKScalar r)
v1) (AstLet @_ @_ @s2 AstVarName s y
var2 AstTensor AstMethodLet s y
u2 AstTensor AstMethodLet s (TKScalar r)
v2)
  | FTKScalar @r1 <- AstTensor AstMethodLet s y -> FullShapeTK y
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor AstMethodLet s y
u1, FTKScalar @r2 <- AstTensor AstMethodLet s y -> FullShapeTK y
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor AstMethodLet s y
u2
  , Just (:~:) @Type r r
Refl <- TypeRep @Type r -> TypeRep @Type r -> Maybe ((:~:) @Type r r)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r1) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r2)
  , Just (:~:) @AstSpanType s s
Refl <- forall (s1 :: AstSpanType) (s2 :: AstSpanType).
(AstSpan s1, AstSpan s2) =>
Maybe ((:~:) @AstSpanType s1 s2)
sameAstSpan @s1 @s2 =
    AstVarName s y
var1 AstVarName s y -> AstVarName s y -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s y
AstVarName s y
var2 Bool -> Bool -> Bool
&& AstTensor AstMethodLet s (TKScalar r)
-> AstTensor AstMethodLet s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor AstMethodLet s y
AstTensor AstMethodLet s (TKScalar r)
u1 AstTensor AstMethodLet s (TKScalar r)
AstTensor AstMethodLet s y
u2 Bool -> Bool -> Bool
&& AstTensor AstMethodLet s (TKScalar r)
-> AstTensor AstMethodLet s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor AstMethodLet s (TKScalar r)
v1 AstTensor AstMethodLet s (TKScalar r)
v2
eqK (AstPrimalPart AstTensor ms FullSpan (TKScalar r)
u1) (AstPrimalPart AstTensor ms FullSpan (TKScalar r)
u2) = AstTensor ms FullSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms FullSpan (TKScalar r)
u1 AstTensor ms FullSpan (TKScalar r)
u2
eqK (AstDualPart AstTensor ms FullSpan (TKScalar r)
u1) (AstDualPart AstTensor ms FullSpan (TKScalar r)
u2) = AstTensor ms FullSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms FullSpan (TKScalar r)
u1 AstTensor ms FullSpan (TKScalar r)
u2
eqK (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u1) (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u2) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms PrimalSpan (TKScalar r)
u1 AstTensor ms PrimalSpan (TKScalar r)
u2
eqK (AstFromDual AstTensor ms DualSpan (TKScalar r)
u1) (AstFromDual AstTensor ms DualSpan (TKScalar r)
u2) = AstTensor ms DualSpan (TKScalar r)
-> AstTensor ms DualSpan (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms DualSpan (TKScalar r)
u1 AstTensor ms DualSpan (TKScalar r)
u2
eqK (AstPlusK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
v1) (AstPlusK AstTensor ms s (TKScalar r)
u2 AstTensor ms s (TKScalar r)
v2) =
  AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
v1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v2 Bool -> Bool -> Bool
|| AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
v1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2
eqK (AstTimesK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
v1) (AstTimesK AstTensor ms s (TKScalar r)
u2 AstTensor ms s (TKScalar r)
v2) =
  AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
v1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v2 Bool -> Bool -> Bool
|| AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
v1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2
eqK (AstN1K OpCodeNum1
opCode1 AstTensor ms s (TKScalar r)
u1) (AstN1K OpCodeNum1
opCode2 AstTensor ms s (TKScalar r)
u2) = OpCodeNum1
opCode1 OpCodeNum1 -> OpCodeNum1 -> Bool
forall a. Eq a => a -> a -> Bool
== OpCodeNum1
opCode2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2
eqK (AstR1K OpCode1
opCode1 AstTensor ms s (TKScalar r)
u1) (AstR1K OpCode1
opCode2 AstTensor ms s (TKScalar r)
u2) = OpCode1
opCode1 OpCode1 -> OpCode1 -> Bool
forall a. Eq a => a -> a -> Bool
== OpCode1
opCode2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2
eqK (AstR2K OpCode2
opCode1 AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
v1) (AstR2K OpCode2
opCode2 AstTensor ms s (TKScalar r)
u2 AstTensor ms s (TKScalar r)
v2) =
  OpCode2
opCode1 OpCode2 -> OpCode2 -> Bool
forall a. Eq a => a -> a -> Bool
== OpCode2
opCode2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
v1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v2
eqK (AstI2K OpCodeIntegral2
opCode1 AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
v1) (AstI2K OpCodeIntegral2
opCode2 AstTensor ms s (TKScalar r)
u2 AstTensor ms s (TKScalar r)
v2) =
  OpCodeIntegral2
opCode1 OpCodeIntegral2 -> OpCodeIntegral2 -> Bool
forall a. Eq a => a -> a -> Bool
== OpCodeIntegral2
opCode2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
u1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u2 Bool -> Bool -> Bool
&& AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r)
v1 AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v2
eqK (AstConcreteK r
u1) (AstConcreteK r
u2) = r
u1 r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
u2
eqK (AstFloorK @r1 AstTensor ms PrimalSpan (TKScalar r1)
u1) (AstFloorK @r2 AstTensor ms PrimalSpan (TKScalar r1)
u2)
  | Just (:~:) @Type r1 r1
Refl <- TypeRep @Type r1 -> TypeRep @Type r1 -> Maybe ((:~:) @Type r1 r1)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r1) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r2) = AstTensor ms PrimalSpan (TKScalar r1)
-> AstTensor ms PrimalSpan (TKScalar r1) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms PrimalSpan (TKScalar r1)
u1 AstTensor ms PrimalSpan (TKScalar r1)
AstTensor ms PrimalSpan (TKScalar r1)
u2
eqK (AstFromIntegralK @r1 AstTensor ms PrimalSpan (TKScalar r1)
u1) (AstFromIntegralK @r2 AstTensor ms PrimalSpan (TKScalar r1)
u2)
  | Just (:~:) @Type r1 r1
Refl <- TypeRep @Type r1 -> TypeRep @Type r1 -> Maybe ((:~:) @Type r1 r1)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r1) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r2) = AstTensor ms PrimalSpan (TKScalar r1)
-> AstTensor ms PrimalSpan (TKScalar r1) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms PrimalSpan (TKScalar r1)
u1 AstTensor ms PrimalSpan (TKScalar r1)
AstTensor ms PrimalSpan (TKScalar r1)
u2
eqK (AstCastK @r1 AstTensor ms s (TKScalar r1)
u1) (AstCastK @r2 AstTensor ms s (TKScalar r1)
u2)
  | Just (:~:) @Type r1 r1
Refl <- TypeRep @Type r1 -> TypeRep @Type r1 -> Maybe ((:~:) @Type r1 r1)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r1) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r2) = AstTensor ms s (TKScalar r1)
-> AstTensor ms s (TKScalar r1) -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) r.
AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r) -> Bool
eqK AstTensor ms s (TKScalar r1)
u1 AstTensor ms s (TKScalar r1)
AstTensor ms s (TKScalar r1)
u2
eqK AstTensor ms s (TKScalar r)
_ AstTensor ms s (TKScalar r)
_ = Bool
False

-- Div and mod operations are very costly (simplifying them requires
-- constructing conditionals, etc), so they are not included in IntegralH.
instance (GoodScalar r, IntegralH r, Nested.IntElt r, AstSpan s)
         => IntegralH (AstTensor ms s (TKScalar r)) where
  quotH :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
quotH (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
n) (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
k) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms PrimalSpan (TKScalar r)
n AstTensor ms PrimalSpan (TKScalar r)
k)
  quotH (AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
n) (AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
k)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n
    , FTKS ShS sh
ZSS FullShapeTK x
y <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
k
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n))
    , Just (:~:) @TK x x
Refl <- FullShapeTK x -> FullShapeTK x -> Maybe ((:~:) @TK x x)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x FullShapeTK x
y =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms s a1
n AstTensor ms s a1
AstTensor ms s a1
k)
  quotH (AstConcreteK r
n) (AstConcreteK r
k) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r -> r
forall a. IntegralH a => a -> a -> a
quotH r
r
n r
r
k)
  quotH (AstConcreteK r
0) AstTensor ms s (TKScalar r)
_ = AstTensor ms s (TKScalar r)
0
  quotH AstTensor ms s (TKScalar r)
u (AstConcreteK r
1) = AstTensor ms s (TKScalar r)
u
  quotH (AstI2K OpCodeIntegral2
RemOp AstTensor ms s (TKScalar r)
_ (AstConcreteK r
k)) (AstConcreteK r
k')
    | r
k' r -> r -> Bool
forall a. Ord a => a -> a -> Bool
>= r
r
k Bool -> Bool -> Bool
&& r
k r -> r -> Bool
forall a. Ord a => a -> a -> Bool
>= r
0 = AstTensor ms s (TKScalar r)
0
  quotH (AstI2K OpCodeIntegral2
QuotOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v) AstTensor ms s (TKScalar r)
w = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u (AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKScalar r)
w)
  quotH (AstTimesK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
v) (AstConcreteK r
n')
    | r
n r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
r
n' = AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
v
  quotH AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v =
    let t :: AstTensor ms s (TKScalar r)
t = OpCodeIntegral2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstI2K OpCodeIntegral2
QuotOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v
        (r
u1, r
u2) = AstTensor ms s (TKScalar r) -> (r, r)
forall r (ms :: AstMethodOfSharing) (s :: AstSpanType).
GoodScalar r =>
AstTensor ms s (TKScalar r) -> (r, r)
bounds AstTensor ms s (TKScalar r)
t
    in if r
u1 r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
u2 then AstTensor ms PrimalSpan (TKScalar r) -> AstTensor ms s (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms PrimalSpan y -> AstTensor ms s y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms PrimalSpan y -> AstTensor ms s y
fromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms s (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
u1 else AstTensor ms s (TKScalar r)
t

  remH :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
remH (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
n) (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
k) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. IntegralH a => a -> a -> a
remH AstTensor ms PrimalSpan (TKScalar r)
n AstTensor ms PrimalSpan (TKScalar r)
k)
  remH (AstConvert TKConversion a1 (TKScalar r)
c AstTensor ms s a1
n) (AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
k)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n
    , FTKS ShS sh
ZSS FullShapeTK x
y <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
k
    , Just (:~:) @TK x (TKScalar r)
Refl <- FullShapeTK x
-> FullShapeTK (TKScalar r) -> Maybe ((:~:) @TK x (TKScalar r))
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (TKConversion a1 (TKScalar r)
-> FullShapeTK a1 -> FullShapeTK (TKScalar r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n))
    , Just (:~:) @TK x x
Refl <- FullShapeTK x -> FullShapeTK x -> Maybe ((:~:) @TK x x)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x FullShapeTK x
y =
      TKConversion a1 (TKScalar r)
-> AstTensor ms s a1 -> AstTensor ms s (TKScalar r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKScalar r)
c (AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. IntegralH a => a -> a -> a
remH AstTensor ms s a1
n AstTensor ms s a1
AstTensor ms s a1
k)
  remH (AstConcreteK r
n) (AstConcreteK r
k) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r -> r
forall a. IntegralH a => a -> a -> a
remH r
r
n r
r
k)
  remH (AstConcreteK r
0) AstTensor ms s (TKScalar r)
_ = AstTensor ms s (TKScalar r)
0
  remH AstTensor ms s (TKScalar r)
_ (AstConcreteK r
1) = AstTensor ms s (TKScalar r)
0
  remH (AstI2K OpCodeIntegral2
RemOp AstTensor ms s (TKScalar r)
u (AstConcreteK r
k)) (AstConcreteK r
k')
    | r
k' r -> r -> Bool
forall a. Ord a => a -> a -> Bool
>= r
r
k Bool -> Bool -> Bool
&& r
k r -> r -> Bool
forall a. Ord a => a -> a -> Bool
>= r
0 = OpCodeIntegral2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstI2K OpCodeIntegral2
RemOp AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u (r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
r
k)
  remH (AstI2K OpCodeIntegral2
RemOp AstTensor ms s (TKScalar r)
u (AstConcreteK r
k)) (AstConcreteK r
k')
    | r -> r -> r
forall a. IntegralH a => a -> a -> a
remH r
k r
r
k' r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
0 Bool -> Bool -> Bool
&& r
k r -> r -> Bool
forall a. Ord a => a -> a -> Bool
> r
0 = AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. IntegralH a => a -> a -> a
remH AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
u (r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
r
k')
  remH (AstTimesK (AstConcreteK r
n) AstTensor ms s (TKScalar r)
_) (AstConcreteK r
n')
    | r -> r -> r
forall a. IntegralH a => a -> a -> a
remH r
n r
r
n' r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
0 = AstTensor ms s (TKScalar r)
0
  remH AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v =
    let t :: AstTensor ms s (TKScalar r)
t = OpCodeIntegral2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstI2K OpCodeIntegral2
RemOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v
        (r
u1, r
u2) = AstTensor ms s (TKScalar r) -> (r, r)
forall r (ms :: AstMethodOfSharing) (s :: AstSpanType).
GoodScalar r =>
AstTensor ms s (TKScalar r) -> (r, r)
bounds AstTensor ms s (TKScalar r)
t
    in if r
u1 r -> r -> Bool
forall a. Eq a => a -> a -> Bool
== r
u2 then AstTensor ms PrimalSpan (TKScalar r) -> AstTensor ms s (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms PrimalSpan y -> AstTensor ms s y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms PrimalSpan y -> AstTensor ms s y
fromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms s (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
u1 else AstTensor ms s (TKScalar r)
t
  {-# SPECIALIZE instance IntegralH (AstTensor ms FullSpan (TKScalar Int64)) #-}
  {-# SPECIALIZE instance IntegralH (AstTensor ms PrimalSpan (TKScalar Int64)) #-}
  {-# SPECIALIZE instance IntegralH (AstTensor ms FullSpan (TKScalar CInt)) #-}
  {-# SPECIALIZE instance IntegralH (AstTensor ms PrimalSpan (TKScalar CInt)) #-}

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Fractional (AstTensor ms s (TKScalar r)) where
  AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u / :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
/ AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Fractional a => a -> a -> a
/ AstTensor ms PrimalSpan (TKScalar r)
v
  AstConcreteK r
u / AstConcreteK r
v = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r
r
u r -> r -> r
forall a. Fractional a => a -> a -> a
/ r
r
v
  AstTensor ms s (TKScalar r)
u / AstTensor ms s (TKScalar r)
v = OpCode2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstR2K OpCode2
DivideOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v
  recip :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
recip (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Fractional a => a -> a
recip AstTensor ms PrimalSpan (TKScalar r)
u)
  recip (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r
forall a. Fractional a => a -> a
recip r
r
u)
  recip AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
RecipOp AstTensor ms s (TKScalar r)
u
  fromRational :: Rational -> AstTensor ms s (TKScalar r)
fromRational Rational
r = AstTensor ms PrimalSpan (TKScalar r) -> AstTensor ms s (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms PrimalSpan y -> AstTensor ms s y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms PrimalSpan y -> AstTensor ms s y
fromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms s (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (Rational -> r
forall a. Fractional a => Rational -> a
fromRational Rational
r)

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Floating (AstTensor ms s (TKScalar r)) where
  pi :: AstTensor ms s (TKScalar r)
pi = [Char] -> AstTensor ms s (TKScalar r)
forall a. HasCallStack => [Char] -> a
error [Char]
"pi is not defined for tensors"
  exp :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
exp (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
exp AstTensor ms PrimalSpan (TKScalar r)
u
  exp (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
exp r
r
u
  exp AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
ExpOp AstTensor ms s (TKScalar r)
u
  log :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
log (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
log AstTensor ms PrimalSpan (TKScalar r)
u
  log (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
log r
r
u
  log AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
LogOp AstTensor ms s (TKScalar r)
u
  sqrt :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
sqrt (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
sqrt AstTensor ms PrimalSpan (TKScalar r)
u
  sqrt (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
sqrt r
r
u
  sqrt AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
SqrtOp AstTensor ms s (TKScalar r)
u
  (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) ** :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
** (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a -> a
** AstTensor ms PrimalSpan (TKScalar r)
v
  (AstConcreteK r
u) ** (AstConcreteK r
v) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r
r
u r -> r -> r
forall a. Floating a => a -> a -> a
** r
r
v
  AstTensor ms s (TKScalar r)
u ** AstTensor ms s (TKScalar r)
v = OpCode2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstR2K OpCode2
PowerOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v
  logBase :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
logBase (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a -> a
logBase AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
v
  logBase (AstConcreteK r
u) (AstConcreteK r
v) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r -> r
forall a. Floating a => a -> a -> a
logBase r
r
u r
r
v
  logBase AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v = OpCode2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstR2K OpCode2
LogBaseOp AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v
  sin :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
sin (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
sin AstTensor ms PrimalSpan (TKScalar r)
u
  sin (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
sin r
r
u
  sin AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
SinOp AstTensor ms s (TKScalar r)
u
  cos :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
cos (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
cos AstTensor ms PrimalSpan (TKScalar r)
u
  cos (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
cos r
r
u
  cos AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
CosOp AstTensor ms s (TKScalar r)
u
  tan :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
tan (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
tan AstTensor ms PrimalSpan (TKScalar r)
u
  tan (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
tan r
r
u
  tan AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
TanOp AstTensor ms s (TKScalar r)
u
  asin :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
asin (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
asin AstTensor ms PrimalSpan (TKScalar r)
u
  asin (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
asin r
r
u
  asin AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
AsinOp AstTensor ms s (TKScalar r)
u
  acos :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
acos (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
acos AstTensor ms PrimalSpan (TKScalar r)
u
  acos (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
acos r
r
u
  acos AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
AcosOp AstTensor ms s (TKScalar r)
u
  atan :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
atan (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
atan AstTensor ms PrimalSpan (TKScalar r)
u
  atan (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
atan r
r
u
  atan AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
AtanOp AstTensor ms s (TKScalar r)
u
  sinh :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
sinh (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
sinh AstTensor ms PrimalSpan (TKScalar r)
u
  sinh (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
sinh r
r
u
  sinh AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
SinhOp AstTensor ms s (TKScalar r)
u
  cosh :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
cosh (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
cosh AstTensor ms PrimalSpan (TKScalar r)
u
  cosh (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
cosh r
r
u
  cosh AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
CoshOp AstTensor ms s (TKScalar r)
u
  tanh :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
tanh (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
tanh AstTensor ms PrimalSpan (TKScalar r)
u
  tanh (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
tanh r
r
u
  tanh AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
TanhOp AstTensor ms s (TKScalar r)
u
  asinh :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
asinh (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
asinh AstTensor ms PrimalSpan (TKScalar r)
u
  asinh (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
asinh r
r
u
  asinh AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
AsinhOp AstTensor ms s (TKScalar r)
u
  acosh :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
acosh (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
acosh AstTensor ms PrimalSpan (TKScalar r)
u
  acosh (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
acosh r
r
u
  acosh AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
AcoshOp AstTensor ms s (TKScalar r)
u
  atanh :: AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
atanh (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Floating a => a -> a
atanh AstTensor ms PrimalSpan (TKScalar r)
u
  atanh (AstConcreteK r
u) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Floating a => a -> a
atanh r
r
u
  atanh AstTensor ms s (TKScalar r)
u = OpCode1
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstR1K OpCode1
AtanhOp AstTensor ms s (TKScalar r)
u

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => RealFloatH (AstTensor ms s (TKScalar r)) where
  atan2H :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
atan2H (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u) (AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v) = AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKScalar r)
 -> AstTensor ms FullSpan (TKScalar r))
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. RealFloatH a => a -> a -> a
atan2H AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
v
  atan2H (AstConcreteK r
u) (AstConcreteK r
v) = r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r -> r
forall a. RealFloatH a => a -> a -> a
atan2H r
r
u r
r
v
  atan2H AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v = OpCode2
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r)
AstR2K OpCode2
Atan2Op AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
v


-- * Unlawful numeric instances for ranked AST; lawful modulo evaluation

instance (GoodScalar r, AstSpan s)
         => Num (AstTensor ms s (TKR n r)) where
  + :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
(+) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a -> a
(+)
  (-) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 (-)
  * :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
(*) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a -> a
(*)
  negate :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
negate = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
negate
  abs :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
abs = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
abs
  signum :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
signum = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
signum
  fromInteger :: Integer -> AstTensor ms s (TKR n r)
fromInteger Integer
i = [Char] -> AstTensor ms s (TKR n r)
forall a. HasCallStack => [Char] -> a
error ([Char] -> AstTensor ms s (TKR n r))
-> [Char] -> AstTensor ms s (TKR n r)
forall a b. (a -> b) -> a -> b
$ [Char]
"fromInteger is not defined for ranked tensors: "
                          [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
i

instance (GoodScalar r, IntegralH r, Nested.IntElt r, AstSpan s)
         => IntegralH (AstTensor ms s (TKR n r)) where
  quotH :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
quotH = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. IntegralH a => a -> a -> a
quotH
  remH :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
remH = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. IntegralH a => a -> a -> a
remH

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Fractional (AstTensor ms s (TKR n r)) where
  / :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
(/) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Fractional a => a -> a -> a
(/)
  recip :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
recip = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Fractional a => a -> a
recip
  fromRational :: Rational -> AstTensor ms s (TKR n r)
fromRational Rational
r = [Char] -> AstTensor ms s (TKR n r)
forall a. HasCallStack => [Char] -> a
error ([Char] -> AstTensor ms s (TKR n r))
-> [Char] -> AstTensor ms s (TKR n r)
forall a b. (a -> b) -> a -> b
$ [Char]
"fromRational is not defined for ranked tensors: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Rational -> [Char]
forall a. Show a => a -> [Char]
show Rational
r

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Floating (AstTensor ms s (TKR n r)) where
  pi :: AstTensor ms s (TKR n r)
pi = [Char] -> AstTensor ms s (TKR n r)
forall a. HasCallStack => [Char] -> a
error [Char]
"pi is not defined for tensors"
  exp :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
exp = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
exp
  log :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
log = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
log
  sqrt :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
sqrt = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
sqrt
  ** :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
(**) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a -> a
(**)
  logBase :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
logBase = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a -> a
logBase
  sin :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
sin = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
sin
  cos :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
cos = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
cos
  tan :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
tan = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
tan
  asin :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
asin = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
asin
  acos :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
acos = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
acos
  atan :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
atan = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
atan
  sinh :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
sinh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
sinh
  cosh :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
cosh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
cosh
  tanh :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
tanh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
tanh
  asinh :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
asinh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
asinh
  acosh :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
acosh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
acosh
  atanh :: AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
atanh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x) -> AstTensor ms s (TKR2 n x)
liftRFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
atanh

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => RealFloatH (AstTensor ms s (TKR n r)) where
  atan2H :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> AstTensor ms s (TKR n r)
atan2H = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r)
forall (n :: Nat) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
-> AstTensor ms s (TKR2 n x)
liftRFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. RealFloatH a => a -> a -> a
atan2H


-- * Unlawful numeric instances for shaped AST; lawful modulo evaluation

instance (GoodScalar r, AstSpan s)
         => Num (AstTensor ms s (TKS sh r)) where
  AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u + :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
+ AstReplicate SNat k
_ STKS{} AstTensor ms s y
v =
    SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y))
-> AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s y
u AstTensor ms s y -> AstTensor ms s y -> AstTensor ms s y
forall a. Num a => a -> a -> a
+ AstTensor ms s y
AstTensor ms s y
v
  AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u + AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Num a => a -> a -> a
+ AstTensor ms PrimalSpan (TKS sh r)
v
  AstFromDual AstTensor ms DualSpan (TKS sh r)
u + AstFromDual AstTensor ms DualSpan (TKS sh r)
v = AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms DualSpan (TKS sh r)
u AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms DualSpan (TKS sh r)
forall a. Num a => a -> a -> a
+ AstTensor ms DualSpan (TKS sh r)
v
  AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
u + AstConvert TKConversion a1 (TKS sh r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s (TKS sh r))
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s a1
u AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a -> a
+ AstTensor ms s a1
AstTensor ms s a1
v
  AstConcreteS Shaped sh r
z + AstTensor ms s (TKS sh r)
u | Just r
0 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
z = AstTensor ms s (TKS sh r)
u
  AstTensor ms s (TKS sh r)
u + AstConcreteS Shaped sh r
z | Just r
0 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
z = AstTensor ms s (TKS sh r)
u
  AstConcreteS Shaped sh r
n + AstConcreteS Shaped sh r
k = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
+ Shaped sh r
Shaped sh r
k)
  AstConcreteS Shaped sh r
n + AstPlusS (AstConcreteS Shaped sh r
k) AstTensor ms s (TKS2 sh (TKScalar r))
u =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
+ Shaped sh r
Shaped sh r
k)) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  AstPlusS (AstConcreteS Shaped sh r
n) AstTensor ms s (TKS2 sh (TKScalar r))
u + AstConcreteS Shaped sh r
k =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
+ Shaped sh r
Shaped sh r
k)) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  AstPlusS (AstConcreteS Shaped sh r
n) AstTensor ms s (TKS2 sh (TKScalar r))
u + AstPlusS (AstConcreteS Shaped sh r
k) AstTensor ms s (TKS2 sh (TKScalar r))
v =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
+ Shaped sh r
Shaped sh r
k)) (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v)

--  AstN1S NegateOp (AstVar var) + AstVar var'
--    | var == var' = 0
  AstN1S OpCodeNum1
NegateOp (AstVar AstVarName s (TKS2 sh (TKScalar r))
var) + AstPlusS (AstVar AstVarName s (TKS2 sh (TKScalar r))
var') AstTensor ms s (TKS2 sh (TKScalar r))
u
    | AstVarName s (TKS2 sh (TKScalar r))
var AstVarName s (TKS2 sh (TKScalar r))
-> AstVarName s (TKS2 sh (TKScalar r)) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKS2 sh (TKScalar r))
AstVarName s (TKS2 sh (TKScalar r))
var' = AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
--  AstVar var' + AstN1S NegateOp (AstVar var)
--    | var == var' = 0
  AstVar AstVarName s (TKS sh r)
var' + AstPlusS (AstN1S OpCodeNum1
NegateOp (AstVar AstVarName s (TKS2 sh (TKScalar r))
var)) AstTensor ms s (TKS2 sh (TKScalar r))
u
    | AstVarName s (TKS2 sh (TKScalar r))
var AstVarName s (TKS2 sh (TKScalar r))
-> AstVarName s (TKS2 sh (TKScalar r)) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKS sh r)
AstVarName s (TKS2 sh (TKScalar r))
var' = AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u

  AstPlusS u :: AstTensor ms s (TKS2 sh (TKScalar r))
u@AstConcreteS{} AstTensor ms s (TKS2 sh (TKScalar r))
v + AstTensor ms s (TKS sh r)
w = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS sh r)
w)
  AstTensor ms s (TKS sh r)
u + v :: AstTensor ms s (TKS sh r)
v@AstConcreteS{} = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
v AstTensor ms s (TKS sh r)
u
  AstTensor ms s (TKS sh r)
u + AstPlusS v :: AstTensor ms s (TKS2 sh (TKScalar r))
v@AstConcreteS{} AstTensor ms s (TKS2 sh (TKScalar r))
w = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w)
  AstTensor ms s (TKS sh r)
u + AstTensor ms s (TKS sh r)
v = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v

  AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u * :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
* AstReplicate SNat k
_ STKS{} AstTensor ms s y
v =
    SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y))
-> AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s y
u AstTensor ms s y -> AstTensor ms s y -> AstTensor ms s y
forall a. Num a => a -> a -> a
* AstTensor ms s y
AstTensor ms s y
v
  AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u * AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms PrimalSpan (TKS sh r)
v
--  AstFromDual{} * AstFromDual{} = 0
  AstConcreteS Shaped sh r
z * AstTensor ms s (TKS sh r)
_ | Just r
0 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
z = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS Shaped sh r
Shaped sh r
z
  AstTensor ms s (TKS sh r)
_ * AstConcreteS Shaped sh r
z | Just r
0 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
z = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS Shaped sh r
Shaped sh r
z
  AstConcreteS Shaped sh r
s * AstTensor ms s (TKS sh r)
u | Just r
1 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
s = AstTensor ms s (TKS sh r)
u
  AstTensor ms s (TKS sh r)
u * AstConcreteS Shaped sh r
s | Just r
1 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
s = AstTensor ms s (TKS sh r)
u
  AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
u * AstConvert TKConversion a1 (TKS sh r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s (TKS sh r))
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s a1
u AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a -> a
* AstTensor ms s a1
AstTensor ms s a1
v
  AstConcreteS Shaped sh r
n * AstConcreteS Shaped sh r
k = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
* Shaped sh r
Shaped sh r
k)
  AstConcreteS Shaped sh r
n * AstTimesS (AstConcreteS Shaped sh r
k) AstTensor ms s (TKS2 sh (TKScalar r))
u =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
* Shaped sh r
Shaped sh r
k)) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  AstTimesS (AstConcreteS Shaped sh r
n) AstTensor ms s (TKS2 sh (TKScalar r))
u * AstConcreteS Shaped sh r
k =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
* Shaped sh r
Shaped sh r
k)) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  AstTimesS (AstConcreteS Shaped sh r
n) AstTensor ms s (TKS2 sh (TKScalar r))
u * AstTimesS (AstConcreteS Shaped sh r
k) AstTensor ms s (TKS2 sh (TKScalar r))
v =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r
Shaped sh r
n Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Num a => a -> a -> a
* Shaped sh r
Shaped sh r
k)) (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v)

  u :: AstTensor ms s (TKS sh r)
u@AstConcreteS{} * AstPlusS AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS2 sh (TKScalar r))
w = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v) (AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w)
  AstTimesS u :: AstTensor ms s (TKS2 sh (TKScalar r))
u@AstConcreteS{} AstTensor ms s (TKS2 sh (TKScalar r))
x * AstPlusS AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS2 sh (TKScalar r))
w =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
x (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v) (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w))
  AstPlusS AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS2 sh (TKScalar r))
w * u :: AstTensor ms s (TKS sh r)
u@AstConcreteS{} = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
u) (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
u)
  AstPlusS AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS2 sh (TKScalar r))
w * AstTimesS u :: AstTensor ms s (TKS2 sh (TKScalar r))
u@AstConcreteS{} AstTensor ms s (TKS2 sh (TKScalar r))
x =
    AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u) (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u)) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
x

  AstN1S OpCodeNum1
NegateOp AstTensor ms s (TKS2 sh (TKScalar r))
u * AstN1S OpCodeNum1
NegateOp AstTensor ms s (TKS2 sh (TKScalar r))
v = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v

  AstTimesS u :: AstTensor ms s (TKS2 sh (TKScalar r))
u@AstConcreteS{} AstTensor ms s (TKS2 sh (TKScalar r))
v * AstTensor ms s (TKS sh r)
w = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS sh r)
w)
  AstTensor ms s (TKS sh r)
u * v :: AstTensor ms s (TKS sh r)
v@AstConcreteS{} = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
v AstTensor ms s (TKS sh r)
u
  AstTensor ms s (TKS sh r)
u * AstTimesS v :: AstTensor ms s (TKS2 sh (TKScalar r))
v@AstConcreteS{} AstTensor ms s (TKS2 sh (TKScalar r))
w = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v (AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w)
  AstTensor ms s (TKS sh r)
u * AstTensor ms s (TKS sh r)
v = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v

  negate :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
negate (AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u) = SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s y
forall a. Num a => a -> a
negate AstTensor ms s y
u)
  negate (AstCond AstBool ms
b AstTensor ms s (TKS sh r)
n AstTensor ms s (TKS sh r)
k) = AstBool ms
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing) (b :: AstSpanType).
AstBool a -> AstTensor a b c -> AstTensor a b c -> AstTensor a b c
AstCond AstBool ms
b (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
n) (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
k)
-- TODO: negate (AstBuild1 k stk (var, v)) = AstBuild1 k stk (var, negate v)
  negate (AstLet AstVarName s y
var AstTensor AstMethodLet s y
n AstTensor AstMethodLet s (TKS sh r)
k) = AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s (TKS sh r)
-> AstTensor AstMethodLet s (TKS sh r)
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s y
var AstTensor AstMethodLet s y
n (AstTensor AstMethodLet s (TKS sh r)
-> AstTensor AstMethodLet s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor AstMethodLet s (TKS sh r)
k)
  negate (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
n) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms PrimalSpan (TKS sh r)
n)
  negate (AstFromDual AstTensor ms DualSpan (TKS sh r)
n) = AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms DualSpan (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms DualSpan (TKS sh r)
n)
  negate (AstPlusS AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS2 sh (TKScalar r))
v) = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstPlusS (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u) (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v)
  negate (AstTimesS AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS2 sh (TKScalar r))
v) = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstTimesS (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v
  negate (AstN1S OpCodeNum1
NegateOp AstTensor ms s (TKS2 sh (TKScalar r))
u) = AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  negate (AstN1S OpCodeNum1
SignumOp AstTensor ms s (TKS2 sh (TKScalar r))
u) = OpCodeNum1
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
OpCodeNum1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstN1S OpCodeNum1
SignumOp (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u)
  negate (AstI2S OpCodeIntegral2
QuotOp AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS2 sh (TKScalar r))
v) = OpCodeIntegral2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstI2S OpCodeIntegral2
QuotOp (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v
    -- v is likely positive and let's keep it so
  negate (AstI2S OpCodeIntegral2
RemOp AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS2 sh (TKScalar r))
v) = OpCodeIntegral2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstI2S OpCodeIntegral2
RemOp (AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u) AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v
    -- v is likely positive and let's keep it so
  negate (AstConcreteS Shaped sh r
n) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r
forall a. Num a => a -> a
negate Shaped sh r
Shaped sh r
n)
  negate (AstGatherS @shm @shn @shp ShS shn
shn AstTensor ms s (TKS2 ((++) @Nat shp shn) x)
v (AstVarListS shm
vars, AstIxS ms shp
ix)) =
    forall (shm :: [Nat]) (shn :: [Nat]) (shp :: [Nat]) (x :: TK)
       (b :: AstSpanType) (a :: AstMethodOfSharing).
ShS shn
-> AstTensor a b (TKS2 ((++) @Nat shp shn) x)
-> (AstVarListS shm, AstIxS a shp)
-> AstTensor a b (TKS2 ((++) @Nat shm shn) x)
AstGatherS @shm @shn @shp ShS shn
shn (AstTensor ms s (TKS2 ((++) @Nat shp shn) (TKScalar r))
-> AstTensor ms s (TKS2 ((++) @Nat shp shn) (TKScalar r))
forall a. Num a => a -> a
negate AstTensor ms s (TKS2 ((++) @Nat shp shn) x)
AstTensor ms s (TKS2 ((++) @Nat shp shn) (TKScalar r))
v) (AstVarListS shm
vars, AstIxS ms shp
ix)
  negate (AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
n)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a
negate AstTensor ms s a1
n)
  negate AstTensor ms s (TKS sh r)
u = OpCodeNum1
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
OpCodeNum1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstN1S OpCodeNum1
NegateOp AstTensor ms s (TKS sh r)
u
  abs :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
abs (AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u) = SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s y
forall a. Num a => a -> a
abs AstTensor ms s y
u)
  abs (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
n) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Num a => a -> a
abs AstTensor ms PrimalSpan (TKS sh r)
n)
  abs (AstFromDual AstTensor ms DualSpan (TKS sh r)
n) = AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms DualSpan (TKS sh r)
forall a. Num a => a -> a
abs AstTensor ms DualSpan (TKS sh r)
n)
  abs (AstN1S OpCodeNum1
AbsOp AstTensor ms s (TKS2 sh (TKScalar r))
u) = OpCodeNum1
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
OpCodeNum1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstN1S OpCodeNum1
AbsOp AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  abs (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r
forall a. Num a => a -> a
abs Shaped sh r
Shaped sh r
u)
  abs (AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
n)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a
abs AstTensor ms s a1
n)
  abs (AstN1S OpCodeNum1
NegateOp AstTensor ms s (TKS2 sh (TKScalar r))
u) = AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a
abs AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  abs AstTensor ms s (TKS sh r)
u = OpCodeNum1
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
OpCodeNum1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstN1S OpCodeNum1
AbsOp AstTensor ms s (TKS sh r)
u
  signum :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
signum (AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u) = SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s y
forall a. Num a => a -> a
signum AstTensor ms s y
u)
  signum (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
n) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Num a => a -> a
signum AstTensor ms PrimalSpan (TKS sh r)
n)
  signum (AstFromDual AstTensor ms DualSpan (TKS sh r)
n) = AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a DualSpan c -> AstTensor a FullSpan c
AstFromDual (AstTensor ms DualSpan (TKS sh r)
-> AstTensor ms DualSpan (TKS sh r)
forall a. Num a => a -> a
signum AstTensor ms DualSpan (TKS sh r)
n)
  signum (AstN1S OpCodeNum1
SignumOp AstTensor ms s (TKS2 sh (TKScalar r))
u) = OpCodeNum1
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
OpCodeNum1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstN1S OpCodeNum1
SignumOp AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u
  signum (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r
forall a. Num a => a -> a
signum Shaped sh r
Shaped sh r
u)
  signum (AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
n)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s a1
forall a. Num a => a -> a
signum AstTensor ms s a1
n)
  signum AstTensor ms s (TKS sh r)
u = OpCodeNum1
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
GoodScalar r =>
OpCodeNum1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstN1S OpCodeNum1
SignumOp AstTensor ms s (TKS sh r)
u
  fromInteger :: Integer -> AstTensor ms s (TKS sh r)
fromInteger Integer
i = [Char] -> AstTensor ms s (TKS sh r)
forall a. HasCallStack => [Char] -> a
error ([Char] -> AstTensor ms s (TKS sh r))
-> [Char] -> AstTensor ms s (TKS sh r)
forall a b. (a -> b) -> a -> b
$ [Char]
"fromInteger is not defined for shaped tensors: "
                          [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
i

instance (GoodScalar r, IntegralH r, Nested.IntElt r, AstSpan s)
         => IntegralH (AstTensor ms s (TKS sh r)) where
  quotH :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
quotH (AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u) (AstReplicate SNat k
_ STKS{} AstTensor ms s y
v) =
    SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y))
-> AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s y -> AstTensor ms s y -> AstTensor ms s y
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms s y
u AstTensor ms s y
AstTensor ms s y
v
  quotH (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
n) (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
k) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms PrimalSpan (TKS sh r)
n AstTensor ms PrimalSpan (TKS sh r)
k)
  quotH (AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
n) (AstConvert TKConversion a1 (TKS sh r)
_ AstTensor ms s a1
k)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
k) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms s a1
n AstTensor ms s a1
AstTensor ms s a1
k)
  quotH (AstConcreteS Shaped sh r
n) (AstConcreteS Shaped sh r
k) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. IntegralH a => a -> a -> a
quotH Shaped sh r
Shaped sh r
n Shaped sh r
Shaped sh r
k)
  quotH (AstConcreteS Shaped sh r
z) AstTensor ms s (TKS sh r)
_ | Just r
0 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
z = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS Shaped sh r
Shaped sh r
z
  quotH AstTensor ms s (TKS sh r)
u (AstConcreteS Shaped sh r
s) | Just r
1 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
s = AstTensor ms s (TKS sh r)
u
  quotH (AstI2S OpCodeIntegral2
QuotOp AstTensor ms s (TKS2 sh (TKScalar r))
u AstTensor ms s (TKS2 sh (TKScalar r))
v) AstTensor ms s (TKS sh r)
w = AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. IntegralH a => a -> a -> a
quotH AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
u (AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
v AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
* AstTensor ms s (TKS sh r)
w)
  quotH AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v = OpCodeIntegral2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstI2S OpCodeIntegral2
QuotOp AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v

  remH :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
remH (AstReplicate SNat k
snat stk :: SingletonTK y
stk@STKS{} AstTensor ms s y
u) (AstReplicate SNat k
_ STKS{} AstTensor ms s y
v) =
    SNat k
-> SingletonTK y
-> AstTensor ms s y
-> AstTensor ms s (BuildTensorKind k y)
forall (y :: TK) (k :: Nat) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
SNat k
-> SingletonTK y
-> AstTensor a b y
-> AstTensor a b (BuildTensorKind k y)
AstReplicate SNat k
snat SingletonTK y
stk (AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y))
-> AstTensor ms s y -> AstTensor ms s (BuildTensorKind k y)
forall a b. (a -> b) -> a -> b
$ AstTensor ms s y -> AstTensor ms s y -> AstTensor ms s y
forall a. IntegralH a => a -> a -> a
remH AstTensor ms s y
u AstTensor ms s y
AstTensor ms s y
v
  remH (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
n) (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
k) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. IntegralH a => a -> a -> a
remH AstTensor ms PrimalSpan (TKS sh r)
n AstTensor ms PrimalSpan (TKS sh r)
k)
  remH (AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
n) (AstConvert TKConversion a1 (TKS sh r)
_ AstTensor ms s a1
k)
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
n)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
k) =
      TKConversion a1 (TKS sh r)
-> AstTensor ms s a1 -> AstTensor ms s (TKS sh r)
forall (a1 :: TK) (c :: TK) (a :: AstMethodOfSharing)
       (b :: AstSpanType).
TKConversion a1 c -> AstTensor a b a1 -> AstTensor a b c
AstConvert TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> AstTensor ms s a1 -> AstTensor ms s a1
forall a. IntegralH a => a -> a -> a
remH AstTensor ms s a1
n AstTensor ms s a1
AstTensor ms s a1
k)
  remH (AstConcreteS Shaped sh r
n) (AstConcreteS Shaped sh r
k) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. IntegralH a => a -> a -> a
remH Shaped sh r
Shaped sh r
n Shaped sh r
Shaped sh r
k)
  remH (AstConcreteS Shaped sh r
z) AstTensor ms s (TKS sh r)
_ | Just r
0 <- Shaped sh r -> Maybe r
forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal Shaped sh r
z = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS Shaped sh r
Shaped sh r
z
--  remH _ (AstConcreteS s) | Just 1 <- sunReplicateScal s = AstConcreteS 0
  remH AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v = OpCodeIntegral2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(IntegralH r, IntElt r, GoodScalar r) =>
OpCodeIntegral2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstI2S OpCodeIntegral2
RemOp AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Fractional (AstTensor ms s (TKS sh r)) where
  AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u / :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
/ AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Fractional a => a -> a -> a
/ AstTensor ms PrimalSpan (TKS sh r)
v
  AstConcreteS Shaped sh r
u / AstConcreteS Shaped sh r
v = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r
Shaped sh r
u Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Fractional a => a -> a -> a
/ Shaped sh r
Shaped sh r
v
  AstTensor ms s (TKS sh r)
u / AstTensor ms s (TKS sh r)
v = OpCode2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstR2S OpCode2
DivideOp AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v
  recip :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
recip (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Fractional a => a -> a
recip AstTensor ms PrimalSpan (TKS sh r)
u)
  recip (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r
forall a. Fractional a => a -> a
recip Shaped sh r
Shaped sh r
u)
  recip AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
RecipOp AstTensor ms s (TKS sh r)
u
  fromRational :: Rational -> AstTensor ms s (TKS sh r)
fromRational Rational
r = [Char] -> AstTensor ms s (TKS sh r)
forall a. HasCallStack => [Char] -> a
error ([Char] -> AstTensor ms s (TKS sh r))
-> [Char] -> AstTensor ms s (TKS sh r)
forall a b. (a -> b) -> a -> b
$ [Char]
"fromRational is not defined for shaped tensors: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Rational -> [Char]
forall a. Show a => a -> [Char]
show Rational
r

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Floating (AstTensor ms s (TKS sh r)) where
  pi :: AstTensor ms s (TKS sh r)
pi = [Char] -> AstTensor ms s (TKS sh r)
forall a. HasCallStack => [Char] -> a
error [Char]
"pi is not defined for tensors"
  exp :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
exp (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
exp AstTensor ms PrimalSpan (TKS sh r)
u
  exp (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
exp Shaped sh r
Shaped sh r
u
  exp AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
ExpOp AstTensor ms s (TKS sh r)
u
  log :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
log (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
log AstTensor ms PrimalSpan (TKS sh r)
u
  log (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
log Shaped sh r
Shaped sh r
u
  log AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
LogOp AstTensor ms s (TKS sh r)
u
  sqrt :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
sqrt (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
sqrt AstTensor ms PrimalSpan (TKS sh r)
u
  sqrt (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
sqrt Shaped sh r
Shaped sh r
u
  sqrt AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
SqrtOp AstTensor ms s (TKS sh r)
u
  (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) ** :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
** (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a -> a
** AstTensor ms PrimalSpan (TKS sh r)
v
  (AstConcreteS Shaped sh r
u) ** (AstConcreteS Shaped sh r
v) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r
Shaped sh r
u Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a -> a
** Shaped sh r
Shaped sh r
v
  AstTensor ms s (TKS sh r)
u ** AstTensor ms s (TKS sh r)
v = OpCode2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstR2S OpCode2
PowerOp AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v
  logBase :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
logBase (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a -> a
logBase AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
v
  logBase (AstConcreteS Shaped sh r
u) (AstConcreteS Shaped sh r
v) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a -> a
logBase Shaped sh r
Shaped sh r
u Shaped sh r
Shaped sh r
v
  logBase AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v = OpCode2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstR2S OpCode2
LogBaseOp AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v
  sin :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
sin (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
sin AstTensor ms PrimalSpan (TKS sh r)
u
  sin (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
sin Shaped sh r
Shaped sh r
u
  sin AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
SinOp AstTensor ms s (TKS sh r)
u
  cos :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
cos (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
cos AstTensor ms PrimalSpan (TKS sh r)
u
  cos (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
cos Shaped sh r
Shaped sh r
u
  cos AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
CosOp AstTensor ms s (TKS sh r)
u
  tan :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
tan (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
tan AstTensor ms PrimalSpan (TKS sh r)
u
  tan (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
tan Shaped sh r
Shaped sh r
u
  tan AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
TanOp AstTensor ms s (TKS sh r)
u
  asin :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
asin (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
asin AstTensor ms PrimalSpan (TKS sh r)
u
  asin (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
asin Shaped sh r
Shaped sh r
u
  asin AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
AsinOp AstTensor ms s (TKS sh r)
u
  acos :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
acos (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
acos AstTensor ms PrimalSpan (TKS sh r)
u
  acos (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
acos Shaped sh r
Shaped sh r
u
  acos AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
AcosOp AstTensor ms s (TKS sh r)
u
  atan :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
atan (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
atan AstTensor ms PrimalSpan (TKS sh r)
u
  atan (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
atan Shaped sh r
Shaped sh r
u
  atan AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
AtanOp AstTensor ms s (TKS sh r)
u
  sinh :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
sinh (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
sinh AstTensor ms PrimalSpan (TKS sh r)
u
  sinh (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
sinh Shaped sh r
Shaped sh r
u
  sinh AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
SinhOp AstTensor ms s (TKS sh r)
u
  cosh :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
cosh (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
cosh AstTensor ms PrimalSpan (TKS sh r)
u
  cosh (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
cosh Shaped sh r
Shaped sh r
u
  cosh AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
CoshOp AstTensor ms s (TKS sh r)
u
  tanh :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
tanh (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
tanh AstTensor ms PrimalSpan (TKS sh r)
u
  tanh (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
tanh Shaped sh r
Shaped sh r
u
  tanh AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
TanhOp AstTensor ms s (TKS sh r)
u
  asinh :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
asinh (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
asinh AstTensor ms PrimalSpan (TKS sh r)
u
  asinh (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
asinh Shaped sh r
Shaped sh r
u
  asinh AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
AsinhOp AstTensor ms s (TKS sh r)
u
  acosh :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
acosh (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
acosh AstTensor ms PrimalSpan (TKS sh r)
u
  acosh (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
acosh Shaped sh r
Shaped sh r
u
  acosh AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
AcoshOp AstTensor ms s (TKS sh r)
u
  atanh :: AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
atanh (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. Floating a => a -> a
atanh AstTensor ms PrimalSpan (TKS sh r)
u
  atanh (AstConcreteS Shaped sh r
u) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r
forall a. Floating a => a -> a
atanh Shaped sh r
Shaped sh r
u
  atanh AstTensor ms s (TKS sh r)
u = OpCode1 -> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode1 -> AstTensor a b (TKS sh r) -> AstTensor a b (TKS sh r)
AstR1S OpCode1
AtanhOp AstTensor ms s (TKS sh r)
u

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => RealFloatH (AstTensor ms s (TKS sh r)) where
  atan2H :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
atan2H (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u) (AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v) = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal (AstTensor ms PrimalSpan (TKS sh r)
 -> AstTensor ms FullSpan (TKS sh r))
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
forall a. RealFloatH a => a -> a -> a
atan2H AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
v
  atan2H (AstConcreteS Shaped sh r
u) (AstConcreteS Shaped sh r
v) = Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r))
-> Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall a b. (a -> b) -> a -> b
$ Shaped sh r -> Shaped sh r -> Shaped sh r
forall a. RealFloatH a => a -> a -> a
atan2H Shaped sh r
Shaped sh r
u Shaped sh r
Shaped sh r
v
  atan2H AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v = OpCode2
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType)
       (sh :: [Nat]).
(RealFloatH r, FloatElt r, GoodScalar r) =>
OpCode2
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
-> AstTensor a b (TKS sh r)
AstR2S OpCode2
Atan2Op AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
v


-- * Unlawful numeric instances for mixed AST; lawful modulo evaluation

instance (GoodScalar r, AstSpan s)
         => Num (AstTensor ms s (TKX sh r)) where
  + :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
(+) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a -> a
(+)
  (-) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 (-)
  * :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
(*) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a -> a
(*)
  negate :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
negate = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
negate
  abs :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
abs = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
abs
  signum :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
signum = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
signum
  fromInteger :: Integer -> AstTensor ms s (TKX sh r)
fromInteger Integer
i = [Char] -> AstTensor ms s (TKX sh r)
forall a. HasCallStack => [Char] -> a
error ([Char] -> AstTensor ms s (TKX sh r))
-> [Char] -> AstTensor ms s (TKX sh r)
forall a b. (a -> b) -> a -> b
$ [Char]
"fromInteger is not defined for mixed tensors: "
                          [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
i

instance (GoodScalar r, IntegralH r, Nested.IntElt r, AstSpan s)
         => IntegralH (AstTensor ms s (TKX sh r)) where
  quotH :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
quotH = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. IntegralH a => a -> a -> a
quotH
  remH :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
remH = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. IntegralH a => a -> a -> a
remH

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Fractional (AstTensor ms s (TKX sh r)) where
  / :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
(/) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Fractional a => a -> a -> a
(/)
  recip :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
recip = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Fractional a => a -> a
recip
  fromRational :: Rational -> AstTensor ms s (TKX sh r)
fromRational Rational
r = [Char] -> AstTensor ms s (TKX sh r)
forall a. HasCallStack => [Char] -> a
error ([Char] -> AstTensor ms s (TKX sh r))
-> [Char] -> AstTensor ms s (TKX sh r)
forall a b. (a -> b) -> a -> b
$ [Char]
"fromRational is not defined for mixed tensors: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Rational -> [Char]
forall a. Show a => a -> [Char]
show Rational
r

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => Floating (AstTensor ms s (TKX sh r)) where
  pi :: AstTensor ms s (TKX sh r)
pi = [Char] -> AstTensor ms s (TKX sh r)
forall a. HasCallStack => [Char] -> a
error [Char]
"pi is not defined for tensors"
  exp :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
exp = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
exp
  log :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
log = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
log
  sqrt :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
sqrt = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
sqrt
  ** :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
(**) = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a -> a
(**)
  logBase :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
logBase = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a -> a
logBase
  sin :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
sin = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
sin
  cos :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
cos = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
cos
  tan :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
tan = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
tan
  asin :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
asin = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
asin
  acos :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
acos = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
acos
  atan :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
atan = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
atan
  sinh :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
sinh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
sinh
  cosh :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
cosh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
cosh
  tanh :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
tanh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
tanh
  asinh :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
asinh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
asinh
  acosh :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
acosh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
acosh
  atanh :: AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
atanh = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKX2 sh' x)
liftXFromS1 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. Floating a => a -> a
atanh

instance (GoodScalar r, RealFloatH r, Nested.FloatElt r, AstSpan s)
         => RealFloatH (AstTensor ms s (TKX sh r)) where
  atan2H :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> AstTensor ms s (TKX sh r)
atan2H = (forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r))
 -> AstTensor ms s (TKS2 sh (TKScalar r)))
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r)
forall (sh' :: [Maybe Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
(forall (sh :: [Nat]).
 AstTensor ms s (TKS2 sh x)
 -> AstTensor ms s (TKS2 sh x) -> AstTensor ms s (TKS2 sh x))
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
-> AstTensor ms s (TKX2 sh' x)
liftXFromS2 AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall (sh :: [Nat]).
AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
-> AstTensor ms s (TKS2 sh (TKScalar r))
forall a. RealFloatH a => a -> a -> a
atan2H


-- * Unlawful instances of AST for bool; they are lawful modulo evaluation

-- Simple variable comparisons, if any, come first.
instance Boolean (AstBool ms) where
  true :: AstBool ms
true = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
True
  false :: AstBool ms
false = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
False
  notB :: AstBool ms -> AstBool ms
notB (AstBoolConst Bool
b) = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst (Bool -> AstBool ms) -> Bool -> AstBool ms
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not Bool
b
  notB (AstBoolNot AstBool ms
b) = AstBool ms
b
  notB AstBool ms
b = AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing). AstBool ms -> AstBool ms
AstBoolNot AstBool ms
b
  AstBoolConst Bool
True &&* :: AstBool ms -> AstBool ms -> AstBool ms
&&* AstBool ms
b = AstBool ms
b
  AstBoolConst Bool
False &&* AstBool ms
_b = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
False
  AstBool ms
b &&* AstBoolConst Bool
True = AstBool ms
b
  AstBool ms
_b &&* AstBoolConst Bool
False = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
False
  AstBoolAnd AstBool ms
b AstBool ms
c &&* AstBool ms
d = AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* (AstBool ms
c AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  b :: AstBool ms
b@(AstLeqK AstConcreteK{} AstVar{}) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstLeqK AstConcreteK{} (AstN1K OpCodeNum1
NegateOp
                                    AstVar{})) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstBoolNot
       (AstLeqK AstConcreteK{} AstVar{})) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstBoolNot
       (AstLeqK AstConcreteK{} (AstN1K OpCodeNum1
NegateOp
                                       AstVar{}))) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstBoolNot
       (AstBoolAnd (AstLeqK AstConcreteK{} AstVar{}) AstBool ms
_)) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstBoolNot
       (AstBoolAnd
          (AstLeqK AstConcreteK{}
                   (AstN1K OpCodeNum1
NegateOp AstVar{})) AstBool ms
_)) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstBoolNot
       (AstBoolAnd (AstBoolNot (AstLeqK AstConcreteK{}
                                        AstVar{})) AstBool ms
_)) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  b :: AstBool ms
b@(AstBoolNot
       (AstBoolAnd
          (AstBoolNot
             (AstLeqK AstConcreteK{}
                      (AstN1K OpCodeNum1
NegateOp AstVar{}))) AstBool ms
_)) &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  AstBool ms
b &&* c :: AstBool ms
c@(AstLeqK AstConcreteK{} AstVar{}) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstLeqK AstConcreteK{} (AstN1K OpCodeNum1
NegateOp
                                          AstVar{})) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstBoolNot
             (AstLeqK AstConcreteK{} AstVar{})) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstBoolNot
             (AstLeqK AstConcreteK{} (AstN1K OpCodeNum1
NegateOp
                                             AstVar{}))) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstBoolNot
             (AstBoolAnd (AstLeqK AstConcreteK{} AstVar{}) AstBool ms
_)) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstBoolNot
             (AstBoolAnd
                (AstLeqK AstConcreteK{}
                         (AstN1K OpCodeNum1
NegateOp AstVar{})) AstBool ms
_)) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstBoolNot
             (AstBoolAnd (AstBoolNot (AstLeqK AstConcreteK{}
                                              AstVar{})) AstBool ms
_)) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* c :: AstBool ms
c@(AstBoolNot
             (AstBoolAnd
                (AstBoolNot
                   (AstLeqK AstConcreteK{}
                            (AstN1K OpCodeNum1
NegateOp AstVar{}))) AstBool ms
_)) = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c AstBool ms
b
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstLeqK AstConcreteK{} AstVar{}) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstLeqK AstConcreteK{}
                     (AstN1K OpCodeNum1
NegateOp AstVar{})) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstBoolNot (AstLeqK AstConcreteK{}
                                 AstVar{})) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstBoolNot
               (AstLeqK AstConcreteK{}
                        (AstN1K OpCodeNum1
NegateOp AstVar{}))) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstBoolNot
               (AstBoolAnd (AstLeqK AstConcreteK{}
                                    AstVar{}) AstBool ms
_)) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstBoolNot
               (AstBoolAnd
                  (AstLeqK AstConcreteK{}
                           (AstN1K OpCodeNum1
NegateOp
                                   AstVar{})) AstBool ms
_)) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstBoolNot
               (AstBoolAnd
                  (AstBoolNot
                     (AstLeqK AstConcreteK{}
                              AstVar{})) AstBool ms
_)) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBoolAnd
          c :: AstBool ms
c@(AstBoolNot
               (AstBoolAnd
                  (AstBoolNot
                     (AstLeqK AstConcreteK{}
                              (AstN1K
                                 OpCodeNum1
NegateOp
                                 AstVar{}))) AstBool ms
_)) AstBool ms
d = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
c (AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms
d)
  AstBool ms
b &&* AstBool ms
c = AstBool ms -> AstBool ms -> AstBool ms
forall (ms :: AstMethodOfSharing).
AstBool ms -> AstBool ms -> AstBool ms
AstBoolAnd AstBool ms
b AstBool ms
c
  AstBool ms
b ||* :: AstBool ms -> AstBool ms -> AstBool ms
||* AstBool ms
c = AstBool ms -> AstBool ms
forall b. Boolean b => b -> b
notB (AstBool ms -> AstBool ms
forall b. Boolean b => b -> b
notB AstBool ms
b AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstBool ms -> AstBool ms
forall b. Boolean b => b -> b
notB AstBool ms
c)

-- TODO: refactor with something like liftRFromS2
instance (AstSpan s, GoodScalar r) => EqH (AstTensor ms s) (TKR n r) where
  AstTensor ms s (TKR n r)
v ==. :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> BoolOf (AstTensor ms s)
==. AstTensor ms s (TKR n r)
u = case AstTensor ms s (TKR n r) -> FullShapeTK (TKR n r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKR n r)
v of
    FTKR IShR n
shv' FullShapeTK x
_ -> case AstTensor ms s (TKR n r) -> FullShapeTK (TKR n r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKR n r)
u of
      FTKR IShR n
shu' FullShapeTK x
_ ->
        IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (n :: Nat) r.
IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShR IShR n
shv' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shv ->
          IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (n :: Nat) r.
IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShR IShR n
shu' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shu ->
            case ShS sh -> ShS sh -> Maybe ((:~:) @[Nat] sh sh)
forall (a :: [Nat]) (b :: [Nat]).
ShS a -> ShS b -> Maybe ((:~:) @[Nat] a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality ShS sh
shv ShS sh
shu of
              Just (:~:) @[Nat] sh sh
Refl ->
                ShS sh
-> AstTensor ms PrimalSpan (TKR2 (Rank @Nat sh) (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
ShS sh
-> AstTensor ms s (TKR2 (Rank @Nat sh) x)
-> AstTensor ms s (TKS2 sh x)
cAstSFromR ShS sh
shu (AstTensor ms s (TKR n r) -> AstTensor ms PrimalSpan (TKR n r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKR n r)
v)
                AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). EqH f y => f y -> f y -> BoolOf f
==. ShS sh
-> AstTensor ms PrimalSpan (TKR2 (Rank @Nat sh) (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
ShS sh
-> AstTensor ms s (TKR2 (Rank @Nat sh) x)
-> AstTensor ms s (TKS2 sh x)
cAstSFromR ShS sh
ShS sh
shv (AstTensor ms s (TKR n r) -> AstTensor ms PrimalSpan (TKR n r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKR n r)
u)
              Maybe ((:~:) @[Nat] sh sh)
_ -> [Char] -> BoolOf (AstTensor ms s)
forall a. HasCallStack => [Char] -> a
error ([Char] -> BoolOf (AstTensor ms s))
-> [Char] -> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ [Char]
"(==.): shapes don't match: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (ShS sh, ShS sh) -> [Char]
forall a. Show a => a -> [Char]
show (ShS sh
shu, ShS sh
shv)

instance (AstSpan s, GoodScalar r) => EqH (AstTensor ms s) (TKX sh r) where
  AstTensor ms s (TKX sh r)
v ==. :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> BoolOf (AstTensor ms s)
==. AstTensor ms s (TKX sh r)
u = case AstTensor ms s (TKX sh r) -> FullShapeTK (TKX sh r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKX sh r)
v of
    FTKX IShX sh
shv' FullShapeTK x
_ -> case AstTensor ms s (TKX sh r) -> FullShapeTK (TKX sh r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKX sh r)
u of
      FTKX IShX sh
shu' FullShapeTK x
_ ->
        IShX sh
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (sh' :: [Maybe Nat]) r.
IShX sh'
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShX IShX sh
shv' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shv ->
          IShX sh
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (sh' :: [Maybe Nat]) r.
IShX sh'
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShX IShX sh
shu' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shu ->
            case ShS sh -> ShS sh -> Maybe ((:~:) @[Nat] sh sh)
forall (a :: [Nat]) (b :: [Nat]).
ShS a -> ShS b -> Maybe ((:~:) @[Nat] a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality ShS sh
shv ShS sh
shu of
              Just (:~:) @[Nat] sh sh
Refl ->
                ShS sh
-> AstTensor ms PrimalSpan (TKX sh r)
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK)
       (ms :: AstMethodOfSharing) (s :: AstSpanType).
((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
ShS sh -> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKS2 sh x)
cAstSFromX ShS sh
shu (AstTensor ms s (TKX sh r) -> AstTensor ms PrimalSpan (TKX sh r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKX sh r)
v)
                AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). EqH f y => f y -> f y -> BoolOf f
==. ShS sh
-> AstTensor ms PrimalSpan (TKX sh r)
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK)
       (ms :: AstMethodOfSharing) (s :: AstSpanType).
((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
ShS sh -> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKS2 sh x)
cAstSFromX ShS sh
ShS sh
shv (AstTensor ms s (TKX sh r) -> AstTensor ms PrimalSpan (TKX sh r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKX sh r)
u)
              Maybe ((:~:) @[Nat] sh sh)
_ -> [Char] -> BoolOf (AstTensor ms s)
forall a. HasCallStack => [Char] -> a
error ([Char] -> BoolOf (AstTensor ms s))
-> [Char] -> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ [Char]
"(==.): shapes don't match: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (ShS sh, ShS sh) -> [Char]
forall a. Show a => a -> [Char]
show (ShS sh
shu, ShS sh
shv)

instance (AstSpan s, GoodScalar r) => OrdH (AstTensor ms s) (TKR n r) where
  AstTensor ms s (TKR n r)
v <=. :: AstTensor ms s (TKR n r)
-> AstTensor ms s (TKR n r) -> BoolOf (AstTensor ms s)
<=. AstTensor ms s (TKR n r)
u = case AstTensor ms s (TKR n r) -> FullShapeTK (TKR n r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKR n r)
v of
    FTKR IShR n
shv' FullShapeTK x
_ -> case AstTensor ms s (TKR n r) -> FullShapeTK (TKR n r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKR n r)
u of
      FTKR IShR n
shu' FullShapeTK x
_ ->
        IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (n :: Nat) r.
IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShR IShR n
shv' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shv ->
          IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (n :: Nat) r.
IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShR IShR n
shu' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shu ->
            case ShS sh -> ShS sh -> Maybe ((:~:) @[Nat] sh sh)
forall (a :: [Nat]) (b :: [Nat]).
ShS a -> ShS b -> Maybe ((:~:) @[Nat] a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality ShS sh
shv ShS sh
shu of
              Just (:~:) @[Nat] sh sh
Refl ->
                ShS sh
-> AstTensor ms PrimalSpan (TKR2 (Rank @Nat sh) (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
ShS sh
-> AstTensor ms s (TKR2 (Rank @Nat sh) x)
-> AstTensor ms s (TKS2 sh x)
cAstSFromR ShS sh
shu (AstTensor ms s (TKR n r) -> AstTensor ms PrimalSpan (TKR n r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKR n r)
v)
                AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. ShS sh
-> AstTensor ms PrimalSpan (TKR2 (Rank @Nat sh) (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
ShS sh
-> AstTensor ms s (TKR2 (Rank @Nat sh) x)
-> AstTensor ms s (TKS2 sh x)
cAstSFromR ShS sh
ShS sh
shv (AstTensor ms s (TKR n r) -> AstTensor ms PrimalSpan (TKR n r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKR n r)
u)
              Maybe ((:~:) @[Nat] sh sh)
_ -> [Char] -> BoolOf (AstTensor ms s)
forall a. HasCallStack => [Char] -> a
error ([Char] -> BoolOf (AstTensor ms s))
-> [Char] -> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ [Char]
"(<=.): shapes don't match: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (ShS sh, ShS sh) -> [Char]
forall a. Show a => a -> [Char]
show (ShS sh
shu, ShS sh
shv)

instance (AstSpan s, GoodScalar r) => OrdH (AstTensor ms s) (TKX sh r) where
  AstTensor ms s (TKX sh r)
v <=. :: AstTensor ms s (TKX sh r)
-> AstTensor ms s (TKX sh r) -> BoolOf (AstTensor ms s)
<=. AstTensor ms s (TKX sh r)
u = case AstTensor ms s (TKX sh r) -> FullShapeTK (TKX sh r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKX sh r)
v of
    FTKX IShX sh
shv' FullShapeTK x
_ -> case AstTensor ms s (TKX sh r) -> FullShapeTK (TKX sh r)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s (TKX sh r)
u of
      FTKX IShX sh
shu' FullShapeTK x
_ ->
        IShX sh
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (sh' :: [Maybe Nat]) r.
IShX sh'
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShX IShX sh
shv' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shv ->
          IShX sh
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall (sh' :: [Maybe Nat]) r.
IShX sh'
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShX IShX sh
shu' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
  ShS sh -> BoolOf (AstTensor ms s))
 -> BoolOf (AstTensor ms s))
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> BoolOf (AstTensor ms s))
-> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ \ShS sh
shu ->
            case ShS sh -> ShS sh -> Maybe ((:~:) @[Nat] sh sh)
forall (a :: [Nat]) (b :: [Nat]).
ShS a -> ShS b -> Maybe ((:~:) @[Nat] a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality ShS sh
shv ShS sh
shu of
              Just (:~:) @[Nat] sh sh
Refl ->
                ShS sh
-> AstTensor ms PrimalSpan (TKX sh r)
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK)
       (ms :: AstMethodOfSharing) (s :: AstSpanType).
((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
ShS sh -> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKS2 sh x)
cAstSFromX ShS sh
shu (AstTensor ms s (TKX sh r) -> AstTensor ms PrimalSpan (TKX sh r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKX sh r)
v)
                AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. ShS sh
-> AstTensor ms PrimalSpan (TKX sh r)
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK)
       (ms :: AstMethodOfSharing) (s :: AstSpanType).
((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
ShS sh -> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKS2 sh x)
cAstSFromX ShS sh
ShS sh
shv (AstTensor ms s (TKX sh r) -> AstTensor ms PrimalSpan (TKX sh r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKX sh r)
u)
              Maybe ((:~:) @[Nat] sh sh)
_ -> [Char] -> BoolOf (AstTensor ms s)
forall a. HasCallStack => [Char] -> a
error ([Char] -> BoolOf (AstTensor ms s))
-> [Char] -> BoolOf (AstTensor ms s)
forall a b. (a -> b) -> a -> b
$ [Char]
"(<=.): shapes don't match: "
                           [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (ShS sh, ShS sh) -> [Char]
forall a. Show a => a -> [Char]
show (ShS sh
shu, ShS sh
shv)

-- TODO: share u and v, since they are duplicated here
instance (AstSpan s, GoodScalar r)
         => EqH (AstTensor ms s) (TKScalar r) where
  AstTensor ms s (TKScalar r)
v ==. :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> BoolOf (AstTensor ms s)
==. AstTensor ms s (TKScalar r)
u = AstTensor ms s (TKScalar r)
v AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r)
u AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r)
v
  {- TODO: for this to work, booleans have to be first-class:
  vUnshared ==. uUnshared = astLetFunNoSimplify vUnshared $ \v ->
                            astLetFunNoSimplify uUnshared $ \u ->
    v <=. u &&* u <=. v -}

instance (AstSpan s, GoodScalar r)
         => EqH (AstTensor ms s) (TKS sh r) where
  AstTensor ms s (TKS sh r)
v ==. :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> BoolOf (AstTensor ms s)
==. AstTensor ms s (TKS sh r)
u = AstTensor ms s (TKS sh r)
v AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKS sh r)
u AstBool ms -> AstBool ms -> AstBool ms
forall b. Boolean b => b -> b -> b
&&* AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKS sh r)
v

-- These are common in indexing, so worth optimizing early via AstConcrete.
-- We keep AstConcrete on the left, as with AstPlusK and others.
instance (AstSpan s, GoodScalar r)
         => OrdH (AstTensor ms s) (TKScalar r) where
  AstTensor ms s (TKScalar r)
u <=. :: AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> BoolOf (AstTensor ms s)
<=. AstTensor ms s (TKScalar r)
v | let (r
u1, r
u2) = AstTensor ms s (TKScalar r) -> (r, r)
forall r (ms :: AstMethodOfSharing) (s :: AstSpanType).
GoodScalar r =>
AstTensor ms s (TKScalar r) -> (r, r)
bounds AstTensor ms s (TKScalar r)
u
                (r
v1, r
v2) = AstTensor ms s (TKScalar r) -> (r, r)
forall r (ms :: AstMethodOfSharing) (s :: AstSpanType).
GoodScalar r =>
AstTensor ms s (TKScalar r) -> (r, r)
bounds AstTensor ms s (TKScalar r)
v
          , r
u2 r -> r -> Bool
forall a. Ord a => a -> a -> Bool
<= r
v1 Bool -> Bool -> Bool
|| r
u1 r -> r -> Bool
forall a. Ord a => a -> a -> Bool
> r
v2 = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst (r
u2 r -> r -> Bool
forall a. Ord a => a -> a -> Bool
<= r
v1)
  AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
u <=. AstFromPrimal AstTensor ms PrimalSpan (TKScalar r)
v = AstTensor ms PrimalSpan (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms PrimalSpan (TKScalar r)
v
  AstPrimalPart AstTensor ms FullSpan (TKScalar r)
u <=. AstPrimalPart AstTensor ms FullSpan (TKScalar r)
v = AstTensor ms FullSpan (TKScalar r)
u AstTensor ms FullSpan (TKScalar r)
-> AstTensor ms FullSpan (TKScalar r)
-> BoolOf (AstTensor ms FullSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms FullSpan (TKScalar r)
v
  AstFromDual{} <=. AstFromDual{} = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
True
  AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
u <=. AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS (FTKScalar @ru) <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u
    , FTKS ShS sh
ZSS (FTKScalar @rv) <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v
    , Just (:~:) @Type r r
Refl <- TypeRep @Type r -> TypeRep @Type r -> Maybe ((:~:) @Type r r)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @ru) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @rv)
    = AstTensor ms s a1
u AstTensor ms s a1 -> AstTensor ms s a1 -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s a1
AstTensor ms s a1
v
  AstConcreteK r
u <=. AstConvert TKConversion a1 (TKScalar r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS (FTKScalar @rv) <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v
    , Just (:~:) @Type r r
Refl <- TypeRep @Type r -> TypeRep @Type r -> Maybe ((:~:) @Type r r)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @rv) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r)
    = Shaped ('[] @Nat) r
-> AstTensor ms PrimalSpan (TKS2 ('[] @Nat) (TKScalar r))
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Concrete (TKS2 ('[] @Nat) (TKScalar r))
-> RepConcrete (TKS2 ('[] @Nat) (TKScalar r))
forall (y :: TK). Concrete y -> RepConcrete y
unConcrete (Concrete (TKS2 ('[] @Nat) (TKScalar r))
 -> RepConcrete (TKS2 ('[] @Nat) (TKScalar r)))
-> Concrete (TKS2 ('[] @Nat) (TKScalar r))
-> RepConcrete (TKS2 ('[] @Nat) (TKScalar r))
forall a b. (a -> b) -> a -> b
$ Concrete (TKScalar r) -> Concrete (TKS2 ('[] @Nat) (TKScalar r))
forall r.
GoodScalar r =>
Concrete (TKScalar r) -> Concrete (TKS ('[] @Nat) r)
forall (target :: Target) r.
(ConvertTensor target, GoodScalar r) =>
target (TKScalar r) -> target (TKS ('[] @Nat) r)
sfromK (Concrete (TKScalar r) -> Concrete (TKS2 ('[] @Nat) (TKScalar r)))
-> Concrete (TKScalar r) -> Concrete (TKS2 ('[] @Nat) (TKScalar r))
forall a b. (a -> b) -> a -> b
$ RepConcrete (TKScalar r) -> Concrete (TKScalar r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete r
RepConcrete (TKScalar r)
u) AstTensor ms PrimalSpan (TKS2 ('[] @Nat) (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 ('[] @Nat) (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s a1
AstTensor ms PrimalSpan (TKS2 ('[] @Nat) (TKScalar r))
v
  AstTensor ms s (TKScalar r)
u <=. AstPlusK (AstConcreteK r
v) AstTensor ms s (TKScalar r)
w =
    AstTensor ms s (TKScalar r)
u AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> AstTensor ms s (TKScalar r)
forall a. Num a => a -> a -> a
- r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
r
v AstTensor ms s (TKScalar r)
-> AstTensor ms s (TKScalar r) -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r)
AstTensor ms s (TKScalar r)
w
  AstPlusK (AstConcreteK r
u) AstTensor ms s (TKScalar r)
w <=. AstTensor ms s (TKScalar r)
v =
    r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r)
AstTensor ms PrimalSpan (TKScalar r)
v AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a -> a
- AstTensor ms s (TKScalar r)
AstTensor ms PrimalSpan (TKScalar r)
w
  AstTensor ms s (TKScalar r)
u <=. AstConcreteK r
v =
    r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> r
forall a. Num a => a -> a
negate r
v) AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a
negate AstTensor ms s (TKScalar r)
AstTensor ms PrimalSpan (TKScalar r)
u
  AstConcreteK r
u <=. AstTimesK (AstConcreteK r
v) AstTensor ms s (TKScalar r)
w
    | r
v r -> r -> Bool
forall a. Ord a => a -> a -> Bool
> r
0 Bool -> Bool -> Bool
&& r
u r -> r -> Bool
forall a. Ord a => a -> a -> Bool
>= r
0
    , Just (:~:) @Type r Int64
Refl <- TypeRep @Type r
-> TypeRep @Type Int64 -> Maybe ((:~:) @Type r Int64)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @Int64) =
      r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK ((r
u r -> r -> r
forall a. Num a => a -> a -> a
+ r
r
v r -> r -> r
forall a. Num a => a -> a -> a
- r
1) r -> r -> r
forall a. IntegralH a => a -> a -> a
`quotH` r
r
v) AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r)
AstTensor ms PrimalSpan (TKScalar r)
w -- 10 == 5 * 2, 11 > 5 * 2
  AstConcreteK r
u <=. AstTimesK (AstConcreteK r
v) AstTensor ms s (TKScalar r)
w
    | r
v r -> r -> Bool
forall a. Ord a => a -> a -> Bool
> r
0 Bool -> Bool -> Bool
&& r
u r -> r -> Bool
forall a. Ord a => a -> a -> Bool
< r
0
    , Just (:~:) @Type r Int64
Refl <- TypeRep @Type r
-> TypeRep @Type Int64 -> Maybe ((:~:) @Type r Int64)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @Int64) =
      r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r
u r -> r -> r
forall a. IntegralH a => a -> a -> a
`quotH` r
r
v) AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r)
AstTensor ms PrimalSpan (TKScalar r)
w  -- -10 == 5 * -2, -9 > 5 * -2
  AstConcreteK r
u <=. AstTimesK (AstConcreteK r
v) AstTensor ms s (TKScalar r)
w
    | r
v r -> r -> Bool
forall a. Ord a => a -> a -> Bool
< r
0
    , Just (:~:) @Type r Int64
Refl <- TypeRep @Type r
-> TypeRep @Type Int64 -> Maybe ((:~:) @Type r Int64)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @r) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @Int64) =
      r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
AstTensor a b (TKScalar r)
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstTimesK (r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (r -> AstTensor ms PrimalSpan (TKScalar r))
-> r -> AstTensor ms PrimalSpan (TKScalar r)
forall a b. (a -> b) -> a -> b
$ r -> r
forall a. Num a => a -> a
negate r
r
v) (OpCodeNum1
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing) (b :: AstSpanType).
GoodScalar r =>
OpCodeNum1
-> AstTensor a b (TKScalar r) -> AstTensor a b (TKScalar r)
AstN1K OpCodeNum1
NegateOp AstTensor ms s (TKScalar r)
AstTensor ms PrimalSpan (TKScalar r)
w)
  v :: AstTensor ms s (TKScalar r)
v@AstConcreteK{} <=. AstTensor ms s (TKScalar r)
u =
    AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r) -> AstBool ms
forall r (ms :: AstMethodOfSharing).
GoodScalar r =>
AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r) -> AstBool ms
AstLeqK (AstTensor ms s (TKScalar r) -> AstTensor ms PrimalSpan (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKScalar r)
v) (AstTensor ms s (TKScalar r) -> AstTensor ms PrimalSpan (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKScalar r)
u)
  AstTensor ms s (TKScalar r)
v <=. AstTensor ms s (TKScalar r)
u =
    r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK r
0 AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKScalar r) -> AstTensor ms PrimalSpan (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKScalar r)
u AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
forall a. Num a => a -> a -> a
- AstTensor ms s (TKScalar r) -> AstTensor ms PrimalSpan (TKScalar r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKScalar r)
v

instance (AstSpan s, GoodScalar r)
         => OrdH (AstTensor ms s) (TKS sh r) where
  AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
u <=. :: AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> BoolOf (AstTensor ms s)
<=. AstFromPrimal AstTensor ms PrimalSpan (TKS sh r)
v = AstTensor ms PrimalSpan (TKS sh r)
u AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms PrimalSpan (TKS sh r)
v
  AstFromDual{} <=. AstFromDual{} = Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
True
  AstPrimalPart AstTensor ms FullSpan (TKS sh r)
u <=. AstPrimalPart AstTensor ms FullSpan (TKS sh r)
v = AstTensor ms FullSpan (TKS sh r)
u AstTensor ms FullSpan (TKS sh r)
-> AstTensor ms FullSpan (TKS sh r)
-> BoolOf (AstTensor ms FullSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms FullSpan (TKS sh r)
v
  AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
u <=. AstConvert TKConversion a1 (TKS sh r)
_ AstTensor ms s a1
v
    | FTKS ShS sh
ZSS FullShapeTK x
x <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
u)
    , Just (:~:) @TK x a1
Refl <- FullShapeTK x -> FullShapeTK a1 -> Maybe ((:~:) @TK x a1)
forall (y1 :: TK) (y2 :: TK).
FullShapeTK y1 -> FullShapeTK y2 -> Maybe ((:~:) @TK y1 y2)
matchingFTK FullShapeTK x
x (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v) = AstTensor ms s a1
u AstTensor ms s a1 -> AstTensor ms s a1 -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s a1
AstTensor ms s a1
v
  AstConcreteS Shaped sh r
u <=. AstConvert TKConversion a1 (TKS sh r)
c AstTensor ms s a1
v
    | FTKS ShS sh
ZSS (FTKScalar @rz) <- TKConversion a1 (TKS sh r)
-> FullShapeTK a1 -> FullShapeTK (TKS sh r)
forall (a :: TK) (b :: TK).
TKConversion a b -> FullShapeTK a -> FullShapeTK b
convertFTK TKConversion a1 (TKS sh r)
c (AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v)
    , FTKScalar @ry <- AstTensor ms s a1 -> FullShapeTK a1
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s a1
v
    , Just (:~:) @Type r r
Refl <- TypeRep @Type r -> TypeRep @Type r -> Maybe ((:~:) @Type r r)
forall a b.
TypeRep @Type a -> TypeRep @Type b -> Maybe ((:~:) @Type a b)
forall {k} (f :: k -> Type) (a :: k) (b :: k).
TestEquality @k f =>
f a -> f b -> Maybe ((:~:) @k a b)
testEquality (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @ry) (forall a. Typeable @Type a => TypeRep @Type a
forall {k} (a :: k). Typeable @k a => TypeRep @k a
typeRep @rz) =
      r -> AstTensor ms PrimalSpan (TKScalar r)
forall r (a :: AstMethodOfSharing).
GoodScalar r =>
r -> AstTensor a PrimalSpan (TKScalar r)
AstConcreteK (Concrete (TKScalar r) -> RepConcrete (TKScalar r)
forall (y :: TK). Concrete y -> RepConcrete y
unConcrete (Concrete (TKScalar r) -> RepConcrete (TKScalar r))
-> Concrete (TKScalar r) -> RepConcrete (TKScalar r)
forall a b. (a -> b) -> a -> b
$ Concrete (TKS ('[] @Nat) r) -> Concrete (TKScalar r)
forall r.
GoodScalar r =>
Concrete (TKS ('[] @Nat) r) -> Concrete (TKScalar r)
forall (target :: Target) r.
(ConvertTensor target, GoodScalar r) =>
target (TKS ('[] @Nat) r) -> target (TKScalar r)
kfromS (Concrete (TKS ('[] @Nat) r) -> Concrete (TKScalar r))
-> Concrete (TKS ('[] @Nat) r) -> Concrete (TKScalar r)
forall a b. (a -> b) -> a -> b
$ RepConcrete (TKS ('[] @Nat) r) -> Concrete (TKS ('[] @Nat) r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete Shaped sh r
RepConcrete (TKS ('[] @Nat) r)
u) AstTensor ms PrimalSpan (TKScalar r)
-> AstTensor ms PrimalSpan (TKScalar r)
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s a1
AstTensor ms PrimalSpan (TKScalar r)
v
  AstConcreteS Shaped sh r
u <=. AstConcreteS Shaped sh r
v =
    Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst (Bool -> AstBool ms) -> Bool -> AstBool ms
forall a b. (a -> b) -> a -> b
$ forall (y :: TK). RepConcrete y -> Concrete y
Concrete @(TKS sh r) Shaped sh r
RepConcrete (TKS sh r)
u Concrete (TKS sh r) -> Concrete (TKS sh r) -> BoolOf Concrete
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. RepConcrete (TKS sh r) -> Concrete (TKS sh r)
forall (y :: TK). RepConcrete y -> Concrete y
Concrete Shaped sh r
RepConcrete (TKS sh r)
v
  AstTensor ms s (TKS sh r)
u <=. AstPlusS (AstConcreteS Shaped sh r
v) AstTensor ms s (TKS2 sh (TKScalar r))
w =
    AstTensor ms s (TKS sh r)
u AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> AstTensor ms s (TKS sh r)
forall a. Num a => a -> a -> a
- Shaped sh r -> AstTensor ms PrimalSpan (TKS sh r)
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS Shaped sh r
Shaped sh r
v AstTensor ms s (TKS sh r)
-> AstTensor ms s (TKS sh r) -> BoolOf (AstTensor ms s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKS sh r)
AstTensor ms s (TKS2 sh (TKScalar r))
w
  AstPlusS (AstConcreteS Shaped sh r
u) AstTensor ms s (TKS2 sh (TKScalar r))
w <=. AstTensor ms s (TKS sh r)
v =
    Shaped sh r -> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS Shaped sh r
u AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms s (TKS sh r)
AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
v AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall a. Num a => a -> a -> a
- AstTensor ms s (TKS2 sh (TKScalar r))
AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
w
  AstTensor ms s (TKS sh r)
u <=. AstConcreteS Shaped sh r
v =
    Shaped sh r -> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall r (sh :: [Nat]) (a :: AstMethodOfSharing).
GoodScalar r =>
Shaped sh r -> AstTensor a PrimalSpan (TKS2 sh (TKScalar r))
AstConcreteS (Shaped sh r -> Shaped sh r
forall a. Num a => a -> a
negate Shaped sh r
v) AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> BoolOf (AstTensor ms PrimalSpan)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
-> AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
forall a. Num a => a -> a
negate AstTensor ms s (TKS sh r)
AstTensor ms PrimalSpan (TKS2 sh (TKScalar r))
u
  AstVar AstVarName s (TKS sh r)
u <=. AstVar AstVarName s (TKS sh r)
v | AstVarName s (TKS sh r)
u AstVarName s (TKS sh r) -> AstVarName s (TKS sh r) -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s (TKS sh r)
v =
    Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
True
  AstConvert TKConversion a1 (TKS sh r)
_ (AstVar AstVarName s a1
u) <=. AstConvert TKConversion a1 (TKS sh r)
_ (AstVar AstVarName s a1
v)
    | AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
u AstVarId -> AstVarId -> Bool
forall a. Eq a => a -> a -> Bool
== AstVarName s a1 -> AstVarId
forall (s :: AstSpanType) (y :: TK). AstVarName s y -> AstVarId
varNameToAstVarId AstVarName s a1
v =
      Bool -> AstBool ms
forall (ms :: AstMethodOfSharing). Bool -> AstBool ms
AstBoolConst Bool
True
  AstTensor ms s (TKS sh r)
v <=. AstTensor ms s (TKS sh r)
u = AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r) -> AstBool ms
forall (sh :: [Nat]) r (ms :: AstMethodOfSharing).
GoodScalar r =>
AstTensor ms PrimalSpan (TKS sh r)
-> AstTensor ms PrimalSpan (TKS sh r) -> AstBool ms
AstLeqS (AstTensor ms s (TKS sh r) -> AstTensor ms PrimalSpan (TKS sh r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKS sh r)
v) (AstTensor ms s (TKS sh r) -> AstTensor ms PrimalSpan (TKS sh r)
forall (ms :: AstMethodOfSharing) (y :: TK).
AstTensor ms s y -> AstTensor ms PrimalSpan y
forall (s :: AstSpanType) (ms :: AstMethodOfSharing) (y :: TK).
AstSpan s =>
AstTensor ms s y -> AstTensor ms PrimalSpan y
primalPart AstTensor ms s (TKS sh r)
u)


-- * AstRaw, AstNoVectorize and AstNoSimplify definitions

-- | An AST variant that doesn't vectorize terms and also builds them
-- with ordinary, non-simplifying constructors. It's based on sharing
-- rather than lets and commonly used as the instance for primals
-- inside ADVal and, consequently, used for evaluating delta expressions.
type role AstRaw nominal nominal
newtype AstRaw s y =
  AstRaw {forall (s :: AstSpanType) (y :: TK).
AstRaw s y -> AstTensor AstMethodShare s y
unAstRaw :: AstTensor AstMethodShare s y}
 deriving Int -> AstRaw s y -> [Char] -> [Char]
[AstRaw s y] -> [Char] -> [Char]
AstRaw s y -> [Char]
(Int -> AstRaw s y -> [Char] -> [Char])
-> (AstRaw s y -> [Char])
-> ([AstRaw s y] -> [Char] -> [Char])
-> Show (AstRaw s y)
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
forall (s :: AstSpanType) (y :: TK).
Int -> AstRaw s y -> [Char] -> [Char]
forall (s :: AstSpanType) (y :: TK).
[AstRaw s y] -> [Char] -> [Char]
forall (s :: AstSpanType) (y :: TK). AstRaw s y -> [Char]
$cshowsPrec :: forall (s :: AstSpanType) (y :: TK).
Int -> AstRaw s y -> [Char] -> [Char]
showsPrec :: Int -> AstRaw s y -> [Char] -> [Char]
$cshow :: forall (s :: AstSpanType) (y :: TK). AstRaw s y -> [Char]
show :: AstRaw s y -> [Char]
$cshowList :: forall (s :: AstSpanType) (y :: TK).
[AstRaw s y] -> [Char] -> [Char]
showList :: [AstRaw s y] -> [Char] -> [Char]
Show

-- | An AST variant for testing that doesn't vectorize terms, but still
-- builds them using simplifying smart constructors.
type role AstNoVectorize nominal nominal
newtype AstNoVectorize s y =
  AstNoVectorize {forall (s :: AstSpanType) (y :: TK).
AstNoVectorize s y -> AstTensor AstMethodLet s y
unAstNoVectorize :: AstTensor AstMethodLet s y}
 deriving Int -> AstNoVectorize s y -> [Char] -> [Char]
[AstNoVectorize s y] -> [Char] -> [Char]
AstNoVectorize s y -> [Char]
(Int -> AstNoVectorize s y -> [Char] -> [Char])
-> (AstNoVectorize s y -> [Char])
-> ([AstNoVectorize s y] -> [Char] -> [Char])
-> Show (AstNoVectorize s y)
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
forall (s :: AstSpanType) (y :: TK).
Int -> AstNoVectorize s y -> [Char] -> [Char]
forall (s :: AstSpanType) (y :: TK).
[AstNoVectorize s y] -> [Char] -> [Char]
forall (s :: AstSpanType) (y :: TK). AstNoVectorize s y -> [Char]
$cshowsPrec :: forall (s :: AstSpanType) (y :: TK).
Int -> AstNoVectorize s y -> [Char] -> [Char]
showsPrec :: Int -> AstNoVectorize s y -> [Char] -> [Char]
$cshow :: forall (s :: AstSpanType) (y :: TK). AstNoVectorize s y -> [Char]
show :: AstNoVectorize s y -> [Char]
$cshowList :: forall (s :: AstSpanType) (y :: TK).
[AstNoVectorize s y] -> [Char] -> [Char]
showList :: [AstNoVectorize s y] -> [Char] -> [Char]
Show

-- | An AST variant for testing that vectorizes terms, but builds them
-- with ordinary, non-simplifying constructors.
type role AstNoSimplify nominal nominal
newtype AstNoSimplify s y =
  AstNoSimplify {forall (s :: AstSpanType) (y :: TK).
AstNoSimplify s y -> AstTensor AstMethodLet s y
unAstNoSimplify :: AstTensor AstMethodLet s y}
 deriving Int -> AstNoSimplify s y -> [Char] -> [Char]
[AstNoSimplify s y] -> [Char] -> [Char]
AstNoSimplify s y -> [Char]
(Int -> AstNoSimplify s y -> [Char] -> [Char])
-> (AstNoSimplify s y -> [Char])
-> ([AstNoSimplify s y] -> [Char] -> [Char])
-> Show (AstNoSimplify s y)
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
forall (s :: AstSpanType) (y :: TK).
Int -> AstNoSimplify s y -> [Char] -> [Char]
forall (s :: AstSpanType) (y :: TK).
[AstNoSimplify s y] -> [Char] -> [Char]
forall (s :: AstSpanType) (y :: TK). AstNoSimplify s y -> [Char]
$cshowsPrec :: forall (s :: AstSpanType) (y :: TK).
Int -> AstNoSimplify s y -> [Char] -> [Char]
showsPrec :: Int -> AstNoSimplify s y -> [Char] -> [Char]
$cshow :: forall (s :: AstSpanType) (y :: TK). AstNoSimplify s y -> [Char]
show :: AstNoSimplify s y -> [Char]
$cshowList :: forall (s :: AstSpanType) (y :: TK).
[AstNoSimplify s y] -> [Char] -> [Char]
showList :: [AstNoSimplify s y] -> [Char] -> [Char]
Show


-- * AstRaw, AstNoVectorize and AstNoSimplify type family instances

type instance PrimalOf (AstRaw s) = AstRaw PrimalSpan
type instance DualOf (AstRaw s) = AstTensor AstMethodShare DualSpan
type instance ShareOf (AstRaw s) = AstRaw s
type instance HFunOf (AstRaw s) x y = AstHFun s s x y
type instance BoolOf (AstRaw s) = AstBool AstMethodShare

type instance PrimalOf (AstNoVectorize s) = AstNoVectorize PrimalSpan
type instance DualOf (AstNoVectorize s) = AstTensor AstMethodLet DualSpan
type instance ShareOf (AstNoVectorize s) = AstRaw s
type instance HFunOf (AstNoVectorize s) x z = AstHFun s s x z
type instance BoolOf (AstNoVectorize s) = AstBool AstMethodLet

type instance PrimalOf (AstNoSimplify s) = AstNoSimplify PrimalSpan
type instance DualOf (AstNoSimplify s) = AstTensor AstMethodLet DualSpan
type instance ShareOf (AstNoSimplify s) = AstRaw s
type instance HFunOf (AstNoSimplify s) x z = AstHFun s s x z
type instance BoolOf (AstNoSimplify s) = AstBool AstMethodLet


-- * AstRaw, AstNoVectorize and AstNoSimplify other instances

instance EqH (AstTensor AstMethodShare s) y => EqH (AstRaw s) y where
  AstRaw AstTensor AstMethodShare s y
v ==. :: AstRaw s y -> AstRaw s y -> BoolOf (AstRaw s)
==. AstRaw AstTensor AstMethodShare s y
u = AstTensor AstMethodShare s y
v AstTensor AstMethodShare s y
-> AstTensor AstMethodShare s y
-> BoolOf (AstTensor AstMethodShare s)
forall (f :: Target) (y :: TK). EqH f y => f y -> f y -> BoolOf f
==. AstTensor AstMethodShare s y
u
instance OrdH (AstTensor AstMethodShare s) y => OrdH (AstRaw s) y where
  AstRaw AstTensor AstMethodShare s y
v <=. :: AstRaw s y -> AstRaw s y -> BoolOf (AstRaw s)
<=. AstRaw AstTensor AstMethodShare s y
u = AstTensor AstMethodShare s y
v AstTensor AstMethodShare s y
-> AstTensor AstMethodShare s y
-> BoolOf (AstTensor AstMethodShare s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor AstMethodShare s y
u

deriving instance Eq (AstRaw s y)
deriving instance Ord (AstRaw s y)
deriving instance Num (AstTensor AstMethodShare s y) => Num (AstRaw s y)
deriving instance IntegralH (AstTensor AstMethodShare s y)
                  => IntegralH (AstRaw s y)
deriving instance Fractional (AstTensor AstMethodShare s y)
                  => Fractional (AstRaw s y)
deriving instance Floating (AstTensor AstMethodShare s y)
                  => Floating (AstRaw s y)
deriving instance RealFloatH (AstTensor AstMethodShare s y)
                  => RealFloatH (AstRaw s y)

instance EqH (AstTensor AstMethodLet s) y => EqH (AstNoVectorize s) y where
  AstNoVectorize AstTensor AstMethodLet s y
v ==. :: AstNoVectorize s y
-> AstNoVectorize s y -> BoolOf (AstNoVectorize s)
==. AstNoVectorize AstTensor AstMethodLet s y
u = AstTensor AstMethodLet s y
v AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s y -> BoolOf (AstTensor AstMethodLet s)
forall (f :: Target) (y :: TK). EqH f y => f y -> f y -> BoolOf f
==. AstTensor AstMethodLet s y
u
instance OrdH (AstTensor AstMethodLet s) y => OrdH (AstNoVectorize s) y where
  AstNoVectorize AstTensor AstMethodLet s y
v <=. :: AstNoVectorize s y
-> AstNoVectorize s y -> BoolOf (AstNoVectorize s)
<=. AstNoVectorize AstTensor AstMethodLet s y
u = AstTensor AstMethodLet s y
v AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s y -> BoolOf (AstTensor AstMethodLet s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor AstMethodLet s y
u
deriving instance Eq (AstNoVectorize s y)
deriving instance Ord (AstNoVectorize s y)
deriving instance Num (AstTensor AstMethodLet s y) => Num (AstNoVectorize s y)
deriving instance (IntegralH (AstTensor AstMethodLet s y))
                  => IntegralH (AstNoVectorize s y)
deriving instance Fractional (AstTensor AstMethodLet s y)
                  => Fractional (AstNoVectorize s y)
deriving instance Floating (AstTensor AstMethodLet s y)
                  => Floating (AstNoVectorize s y)
deriving instance (RealFloatH (AstTensor AstMethodLet s y))
                  => RealFloatH (AstNoVectorize s y)

instance EqH (AstTensor AstMethodLet s) y => EqH (AstNoSimplify s) y where
  AstNoSimplify AstTensor AstMethodLet s y
v ==. :: AstNoSimplify s y -> AstNoSimplify s y -> BoolOf (AstNoSimplify s)
==. AstNoSimplify AstTensor AstMethodLet s y
u = AstTensor AstMethodLet s y
v AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s y -> BoolOf (AstTensor AstMethodLet s)
forall (f :: Target) (y :: TK). EqH f y => f y -> f y -> BoolOf f
==. AstTensor AstMethodLet s y
u
instance OrdH (AstTensor AstMethodLet s) y => OrdH (AstNoSimplify s) y where
  AstNoSimplify AstTensor AstMethodLet s y
v <=. :: AstNoSimplify s y -> AstNoSimplify s y -> BoolOf (AstNoSimplify s)
<=. AstNoSimplify AstTensor AstMethodLet s y
u = AstTensor AstMethodLet s y
v AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s y -> BoolOf (AstTensor AstMethodLet s)
forall (f :: Target) (y :: TK). OrdH f y => f y -> f y -> BoolOf f
<=. AstTensor AstMethodLet s y
u
deriving instance Eq (AstNoSimplify s y)
deriving instance Ord (AstNoSimplify s y)
deriving instance Num (AstTensor AstMethodLet s y) => Num (AstNoSimplify s y)
deriving instance (IntegralH (AstTensor AstMethodLet s y))
                  => IntegralH (AstNoSimplify s y)
deriving instance Fractional (AstTensor AstMethodLet s y)
                  => Fractional (AstNoSimplify s y)
deriving instance Floating (AstTensor AstMethodLet s y)
                  => Floating (AstNoSimplify s y)
deriving instance (RealFloatH (AstTensor AstMethodLet s y))
                  => RealFloatH (AstNoSimplify s y)


-- * Misc

astLetFunNoSimplify
  :: forall y z s s2. AstSpan s
  => AstTensor AstMethodLet s y
  -> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
  -> AstTensor AstMethodLet s2 z
astLetFunNoSimplify :: forall (y :: TK) (z :: TK) (s :: AstSpanType) (s2 :: AstSpanType).
AstSpan s =>
AstTensor AstMethodLet s y
-> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> AstTensor AstMethodLet s2 z
astLetFunNoSimplify AstTensor AstMethodLet s y
a AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f | Bool -> AstTensor AstMethodLet s y -> Bool
forall (ms :: AstMethodOfSharing) (s :: AstSpanType) (y :: TK).
Bool -> AstTensor ms s y -> Bool
astIsSmall Bool
True AstTensor AstMethodLet s y
a = AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f AstTensor AstMethodLet s y
a
                            -- too important an optimization to skip
astLetFunNoSimplify AstTensor AstMethodLet s y
a AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f = case AstTensor AstMethodLet s y
a of
  AstFromS' @y2 FullShapeTK z
ftkz AstTensor ms s y
v ->
    let (AstVarName s y
var, AstTensor AstMethodLet s2 z
ast) = FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstVarName s y, AstTensor AstMethodLet s2 z)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing)
       (s2 :: AstSpanType) (z :: TK).
AstSpan s =>
FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor ms s y -> AstTensor ms s2 z)
-> (AstVarName s y, AstTensor ms s2 z)
funToAst2 (AstTensor ms s y -> FullShapeTK y
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms s y
v) Maybe (Int64, Int64)
forall a. Maybe a
Nothing (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s y)
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s2 z
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (y :: TK) (z :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
FullShapeTK z -> AstTensor ms s y -> AstTensor ms s z
cAstFromS @y2 FullShapeTK y
FullShapeTK z
ftkz)
    in AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s2 z
-> AstTensor AstMethodLet s2 z
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s y
var AstTensor ms s y
AstTensor AstMethodLet s y
v AstTensor AstMethodLet s2 z
ast
  AstFromPrimal (AstFromS' @y2 FullShapeTK z
ftkz AstTensor ms s y
vRaw) ->
    let v :: AstTensor ms FullSpan y
v = AstTensor ms PrimalSpan y -> AstTensor ms FullSpan y
forall (c :: TK) (a :: AstMethodOfSharing).
AstTensor a PrimalSpan c -> AstTensor a FullSpan c
AstFromPrimal AstTensor ms s y
AstTensor ms PrimalSpan y
vRaw
        (AstVarName s y
var, AstTensor AstMethodLet s2 z
ast) = FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstVarName s y, AstTensor AstMethodLet s2 z)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing)
       (s2 :: AstSpanType) (z :: TK).
AstSpan s =>
FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor ms s y -> AstTensor ms s2 z)
-> (AstVarName s y, AstTensor ms s2 z)
funToAst2 (AstTensor ms FullSpan y -> FullShapeTK y
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor ms FullSpan y
v) Maybe (Int64, Int64)
forall a. Maybe a
Nothing (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s y)
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s2 z
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (y :: TK) (z :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
FullShapeTK z -> AstTensor ms s y -> AstTensor ms s z
cAstFromS @y2 FullShapeTK y
FullShapeTK z
ftkz)
    in AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s2 z
-> AstTensor AstMethodLet s2 z
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s y
var AstTensor ms FullSpan y
AstTensor AstMethodLet s y
v AstTensor AstMethodLet s2 z
ast
  AstTensor AstMethodLet s y
_ -> case AstTensor AstMethodLet s y -> FullShapeTK y
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing).
AstTensor ms s y -> FullShapeTK y
ftkAst AstTensor AstMethodLet s y
a of
    ftk :: FullShapeTK y
ftk@(FTKR @_ @x2 IShR n
sh' FullShapeTK x
x) ->
      IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> AstTensor AstMethodLet s2 z)
-> AstTensor AstMethodLet s2 z
forall (n :: Nat) r.
IShR n
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShR IShR n
sh' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
  ShS sh -> AstTensor AstMethodLet s2 z)
 -> AstTensor AstMethodLet s2 z)
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (n :: Nat)) =>
    ShS sh -> AstTensor AstMethodLet s2 z)
-> AstTensor AstMethodLet s2 z
forall a b. (a -> b) -> a -> b
$ \(ShS sh
sh :: ShS sh) ->
        let (AstVarName s (TKS2 sh x)
var, AstTensor AstMethodLet s2 z
ast) =
              FullShapeTK (TKS2 sh x)
-> Maybe (Int64, Int64)
-> (AstTensor AstMethodLet s (TKS2 sh x)
    -> AstTensor AstMethodLet s2 z)
-> (AstVarName s (TKS2 sh x), AstTensor AstMethodLet s2 z)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing)
       (s2 :: AstSpanType) (z :: TK).
AstSpan s =>
FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor ms s y -> AstTensor ms s2 z)
-> (AstVarName s y, AstTensor ms s2 z)
funToAst2 (ShS sh -> FullShapeTK x -> FullShapeTK (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK).
ShS sh -> FullShapeTK x -> FullShapeTK (TKS2 sh x)
FTKS ShS sh
sh FullShapeTK x
x) Maybe (Int64, Int64)
forall a. Maybe a
Nothing
                        (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstTensor AstMethodLet s (TKS2 sh x)
    -> AstTensor AstMethodLet s y)
-> AstTensor AstMethodLet s (TKS2 sh x)
-> AstTensor AstMethodLet s2 z
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (y :: TK) (z :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
FullShapeTK z -> AstTensor ms s y -> AstTensor ms s z
cAstFromS @(TKS2 sh x2) FullShapeTK y
ftk)
        in AstVarName s (TKS2 sh x)
-> AstTensor AstMethodLet s (TKS2 sh x)
-> AstTensor AstMethodLet s2 z
-> AstTensor AstMethodLet s2 z
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s (TKS2 sh x)
var (forall (sh :: [Nat]) (x :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
ShS sh
-> AstTensor ms s (TKR2 (Rank @Nat sh) x)
-> AstTensor ms s (TKS2 sh x)
cAstSFromR @sh ShS sh
sh AstTensor AstMethodLet s y
AstTensor AstMethodLet s (TKR2 (Rank @Nat sh) x)
a) AstTensor AstMethodLet s2 z
ast
             -- safe, because subsitution ruled out above
    ftk :: FullShapeTK y
ftk@(FTKX @_ @x IShX sh
sh' FullShapeTK x
x) ->
      IShX sh
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> AstTensor AstMethodLet s2 z)
-> AstTensor AstMethodLet s2 z
forall (sh' :: [Maybe Nat]) r.
IShX sh'
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
    ShS sh -> r)
-> r
withShsFromShX IShX sh
sh' ((forall (sh :: [Nat]).
  ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
  ShS sh -> AstTensor AstMethodLet s2 z)
 -> AstTensor AstMethodLet s2 z)
-> (forall (sh :: [Nat]).
    ((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh :: Nat)) =>
    ShS sh -> AstTensor AstMethodLet s2 z)
-> AstTensor AstMethodLet s2 z
forall a b. (a -> b) -> a -> b
$ \(ShS sh
sh :: ShS sh) ->
        let (AstVarName s (TKS2 sh x)
var, AstTensor AstMethodLet s2 z
ast) =
              FullShapeTK (TKS2 sh x)
-> Maybe (Int64, Int64)
-> (AstTensor AstMethodLet s (TKS2 sh x)
    -> AstTensor AstMethodLet s2 z)
-> (AstVarName s (TKS2 sh x), AstTensor AstMethodLet s2 z)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing)
       (s2 :: AstSpanType) (z :: TK).
AstSpan s =>
FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor ms s y -> AstTensor ms s2 z)
-> (AstVarName s y, AstTensor ms s2 z)
funToAst2 (ShS sh -> FullShapeTK x -> FullShapeTK (TKS2 sh x)
forall (sh :: [Nat]) (x :: TK).
ShS sh -> FullShapeTK x -> FullShapeTK (TKS2 sh x)
FTKS ShS sh
sh FullShapeTK x
x) Maybe (Int64, Int64)
forall a. Maybe a
Nothing
                        (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstTensor AstMethodLet s (TKS2 sh x)
    -> AstTensor AstMethodLet s y)
-> AstTensor AstMethodLet s (TKS2 sh x)
-> AstTensor AstMethodLet s2 z
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (y :: TK) (z :: TK) (ms :: AstMethodOfSharing)
       (s :: AstSpanType).
FullShapeTK z -> AstTensor ms s y -> AstTensor ms s z
cAstFromS @(TKS2 sh x) FullShapeTK y
ftk)
        in AstVarName s (TKS2 sh x)
-> AstTensor AstMethodLet s (TKS2 sh x)
-> AstTensor AstMethodLet s2 z
-> AstTensor AstMethodLet s2 z
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s (TKS2 sh x)
var (forall (sh :: [Nat]) (sh' :: [Maybe Nat]) (x :: TK)
       (ms :: AstMethodOfSharing) (s :: AstSpanType).
((Rank @Nat sh :: Nat) ~ (Rank @(Maybe Nat) sh' :: Nat)) =>
ShS sh -> AstTensor ms s (TKX2 sh' x) -> AstTensor ms s (TKS2 sh x)
cAstSFromX @sh ShS sh
sh AstTensor AstMethodLet s y
AstTensor AstMethodLet s (TKX2 sh x)
a) AstTensor AstMethodLet s2 z
ast
    -- processing product recursively may be not worth it
    FullShapeTK y
ftk -> let (AstVarName s y
var, AstTensor AstMethodLet s2 z
ast) = FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z)
-> (AstVarName s y, AstTensor AstMethodLet s2 z)
forall (s :: AstSpanType) (y :: TK) (ms :: AstMethodOfSharing)
       (s2 :: AstSpanType) (z :: TK).
AstSpan s =>
FullShapeTK y
-> Maybe (Int64, Int64)
-> (AstTensor ms s y -> AstTensor ms s2 z)
-> (AstVarName s y, AstTensor ms s2 z)
funToAst2 FullShapeTK y
ftk Maybe (Int64, Int64)
forall a. Maybe a
Nothing AstTensor AstMethodLet s y -> AstTensor AstMethodLet s2 z
f
           in AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet s2 z
-> AstTensor AstMethodLet s2 z
forall (y :: TK) (c :: TK) (s :: AstSpanType) (b :: AstSpanType).
AstSpan s =>
AstVarName s y
-> AstTensor AstMethodLet s y
-> AstTensor AstMethodLet b c
-> AstTensor AstMethodLet b c
AstLet AstVarName s y
var AstTensor AstMethodLet s y
a AstTensor AstMethodLet s2 z
ast

sunReplicateScal :: Nested.Elt a
                 => Nested.Shaped sh a -> Maybe a
sunReplicateScal :: forall a (sh :: [Nat]). Elt a => Shaped sh a -> Maybe a
sunReplicateScal (Nested.Shaped Mixed (MapJust @Nat sh) a
arr)
  | ([Int] -> Bool) -> Bag [Int] -> Bool
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Bool
all ((Int -> Bool) -> [Int] -> Bool
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Bool
all (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) ([Int] -> Bool) -> ([Int] -> [Int]) -> [Int] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take (ShX (MapJust @Nat sh) Int -> Int
forall (sh :: [Maybe Nat]) i. ShX sh i -> Int
shxLength (Mixed (MapJust @Nat sh) a -> ShX (MapJust @Nat sh) Int
forall (sh :: [Maybe Nat]). Mixed sh a -> IShX sh
forall a (sh :: [Maybe Nat]). Elt a => Mixed sh a -> IShX sh
Nested.mshape Mixed (MapJust @Nat sh) a
arr)))
        (Mixed (MapJust @Nat sh) a -> Bag [Int]
forall (sh :: [Maybe Nat]). Mixed sh a -> Bag [Int]
forall a (sh :: [Maybe Nat]). Elt a => Mixed sh a -> Bag [Int]
Mixed.marrayStrides Mixed (MapJust @Nat sh) a
arr)
  , ShX (MapJust @Nat sh) Int -> Int
forall (sh :: [Maybe Nat]). IShX sh -> Int
shxSize (Mixed (MapJust @Nat sh) a -> ShX (MapJust @Nat sh) Int
forall (sh :: [Maybe Nat]). Mixed sh a -> IShX sh
forall a (sh :: [Maybe Nat]). Elt a => Mixed sh a -> IShX sh
Nested.mshape Mixed (MapJust @Nat sh) a
arr) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 =
    a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ Mixed (MapJust @Nat sh) a -> IIxX (MapJust @Nat sh) -> a
forall (sh :: [Maybe Nat]). Mixed sh a -> IIxX sh -> a
forall a (sh :: [Maybe Nat]). Elt a => Mixed sh a -> IIxX sh -> a
Nested.mindex Mixed (MapJust @Nat sh) a
arr (IIxX (MapJust @Nat sh) -> a) -> IIxX (MapJust @Nat sh) -> a
forall a b. (a -> b) -> a -> b
$ ShX (MapJust @Nat sh) Int -> IIxX (MapJust @Nat sh)
forall (sh :: [Maybe Nat]). IShX sh -> IIxX sh
ixxZero' (ShX (MapJust @Nat sh) Int -> IIxX (MapJust @Nat sh))
-> ShX (MapJust @Nat sh) Int -> IIxX (MapJust @Nat sh)
forall a b. (a -> b) -> a -> b
$ Mixed (MapJust @Nat sh) a -> ShX (MapJust @Nat sh) Int
forall (sh :: [Maybe Nat]). Mixed sh a -> IShX sh
forall a (sh :: [Maybe Nat]). Elt a => Mixed sh a -> IShX sh
Nested.mshape Mixed (MapJust @Nat sh) a
arr
sunReplicateScal Shaped sh a
_ = Maybe a
forall a. Maybe a
Nothing

sunReplicate1 :: Nested.Elt a
              => Nested.Shaped (n ': sh) a -> Maybe (Nested.Shaped sh a)
sunReplicate1 :: forall a (n :: Nat) (sh :: [Nat]).
Elt a =>
Shaped ((':) @Nat n sh) a -> Maybe (Shaped sh a)
sunReplicate1 Shaped ((':) @Nat n sh) a
a | (SNat n
snat :$$ ShS sh
_) <- Shaped ((':) @Nat n sh) a -> ShS ((':) @Nat n sh)
forall (sh :: [Nat]) a. Elt a => Shaped sh a -> ShS sh
Nested.sshape Shaped ((':) @Nat n sh) a
a =
  ShS ((':) @Nat n ('[] @Nat))
-> Shaped ((++) @Nat ((':) @Nat n ('[] @Nat)) sh) a
-> Maybe (Shaped sh a)
forall a (shm :: [Nat]) (shn :: [Nat]).
Elt a =>
ShS shm -> Shaped ((++) @Nat shm shn) a -> Maybe (Shaped shn a)
sunReplicateN (SNat n
snat SNat n -> ShS ('[] @Nat) -> ShS ((':) @Nat n ('[] @Nat))
forall {sh1 :: [Nat]} (n :: Nat) (sh :: [Nat]).
(KnownNat n, ((':) @Nat n sh :: [Nat]) ~ (sh1 :: [Nat])) =>
SNat n -> ShS sh -> ShS sh1
:$$ ShS ('[] @Nat)
forall (sh :: [Nat]).
((sh :: [Nat]) ~ ('[] @Nat :: [Nat])) =>
ShS sh
ZSS) Shaped ((':) @Nat n sh) a
Shaped ((++) @Nat ((':) @Nat n ('[] @Nat)) sh) a
a

sunReplicateN :: Nested.Elt a
              => ShS shm -> Nested.Shaped (shm ++ shn) a
              -> Maybe (Nested.Shaped shn a)
sunReplicateN :: forall a (shm :: [Nat]) (shn :: [Nat]).
Elt a =>
ShS shm -> Shaped ((++) @Nat shm shn) a -> Maybe (Shaped shn a)
sunReplicateN ShS shm
shm a :: Shaped ((++) @Nat shm shn) a
a@(Nested.Shaped Mixed (MapJust @Nat ((++) @Nat shm shn)) a
arr)
  | ([Int] -> Bool) -> Bag [Int] -> Bool
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Bool
all ((Int -> Bool) -> [Int] -> Bool
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Bool
all (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) ([Int] -> Bool) -> ([Int] -> [Int]) -> [Int] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take (ShS shm -> Int
forall (sh :: [Nat]). ShS sh -> Int
shsLength ShS shm
shm)) (Mixed (MapJust @Nat ((++) @Nat shm shn)) a -> Bag [Int]
forall (sh :: [Maybe Nat]). Mixed sh a -> Bag [Int]
forall a (sh :: [Maybe Nat]). Elt a => Mixed sh a -> Bag [Int]
Mixed.marrayStrides Mixed (MapJust @Nat ((++) @Nat shm shn)) a
arr)
  , ShS shm -> Int
forall (sh :: [Nat]). ShS sh -> Int
shsSize ShS shm
shm Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 =
    Shaped shn a -> Maybe (Shaped shn a)
forall a. a -> Maybe a
Just (Shaped shn a -> Maybe (Shaped shn a))
-> Shaped shn a -> Maybe (Shaped shn a)
forall a b. (a -> b) -> a -> b
$ Shaped ((++) @Nat shm shn) a -> IIxS shm -> Shaped shn a
forall (sh1 :: [Nat]) (sh2 :: [Nat]) a.
Elt a =>
Shaped ((++) @Nat sh1 sh2) a -> IIxS sh1 -> Shaped sh2 a
Nested.sindexPartial Shaped ((++) @Nat shm shn) a
a (IIxS shm -> Shaped shn a) -> IIxS shm -> Shaped shn a
forall a b. (a -> b) -> a -> b
$ ShS shm -> IIxS shm
forall (sh :: [Nat]). ShS sh -> IIxS sh
ixsZero ShS shm
shm
sunReplicateN ShS shm
_ Shaped ((++) @Nat shm shn) a
_ = Maybe (Shaped shn a)
forall a. Maybe a
Nothing