Starade göra mer strukturerat på utökad Quantity

Author: Oskar Lundström

Physics/src/Dimensions/Quantity.lhs

@@ -20,9 +20,10 @@ Quantities
 >     , meter, kilogram, second, ampere, kelvin, mole, candela, unitless
 >     , (~=)
 >     , isZero
->     , (#)
+>     , (#), (##)
 >     , (+#), (-#), (*#), (/#)
 >     , sinq, cosq, asinq, acosq, atanq, expq, logq
+>     , qfold
 >     ) where
 
 
@@ -340,26 +341,26 @@ The other functions can be written as similar power series and we'll see on thos
 
 We quickly realize a pattern, so let's generalize a bit.
 
-> qmap :: (a -> b) -> Quantity One a -> Quantity One b
-> qmap f (ValQuantity d1 v) = ValQuantity d1 (f v)
+> qmap :: (a -> b) -> Quantity dim a -> Quantity dim b
+> qmap f (ValQuantity d v) = ValQuantity d (f v)
 
-> qmap' :: (a -> b) -> Quantity dim a -> Quantity dim b
-> qmap' f (ValQuantity d v) = ValQuantity d (f v)
+> instance Functor (Quantity d) where
+>   fmap = qmap
 
 > qfold :: (a -> a -> b) -> Quantity dim a -> Quantity dim a -> Quantity dim b
 > qfold f (ValQuantity d v1) (ValQuantity _ v2) = ValQuantity d (f v1 v2)
 
 > sinq, cosq, asinq, acosq, atanq, expq, logq :: (Floating v) =>
 >   Quantity One v -> Quantity One v
-> sinq  = qmap sin
-> cosq  = qmap cos
-> asinq = qmap asin
-> acosq = qmap acos
-> atanq = qmap atan
-> expq  = qmap exp
-> logq  = qmap log
+> sinq  = fmap sin
+> cosq  = fmap cos
+> asinq = fmap asin
+> acosq = fmap acos
+> atanq = fmap atan
+> expq  = fmap exp
+> logq  = fmap log
 
-Why not make `Quantity` an instance of `Num`, `Fractional`, `Floating` och `Functor`? The reason is that the functions of those type classes have the following type
+Why not make `Quantity` an instance of `Num`, `Fractional` and `Floating`? The reason is that the functions of those type classes have the following type
 
 < (*) :: (Num a) => a -> a -> a
 
@@ -372,7 +373,7 @@ The input here may actually be of *different* types, and the output has a type d
 
 However, operations with only scalars (type `One`) has types compatible with `Num`.
 
-**Exercise** `Quantity One` has compatible types. Make it an instance of `Num`, `Fractional`, `Floating` and `Functor`.
+**Exercise** `Quantity One` has compatible types. Make it an instance of `Num`, `Fractional` and `Floating`.
 
 <details>
 <summary>**Solution**</summary>
@@ -382,8 +383,8 @@ However, operations with only scalars (type `One`) has types compatible with `Nu
 >   (+) = (+#)
 >   (-) = (-#)
 >   (*) = (*#)
->   abs = qmap abs
->   signum = qmap signum
+>   abs = fmap abs
+>   signum = fmap signum
 >   fromInteger n = ValQuantity V.one (fromInteger n)
 
 > instance (Fractional v) => Fractional (Quantity One v) where
@@ -399,14 +400,11 @@ However, operations with only scalars (type `One`) has types compatible with `Nu
 >   asin  = asinq
 >   acos  = acosq
 >   atan  = atanq
->   sinh  = qmap sinh
->   cosh  = qmap cosh
->   asinh = qmap asinh
->   acosh = qmap acosh
->   atanh = qmap atanh
-
-> instance Functor (Quantity One) where
->   fmap = qmap
+>   sinh  = fmap sinh
+>   cosh  = fmap cosh
+>   asinh = fmap asinh
+>   acosh = fmap acosh
+>   atanh = fmap atanh
 
  </div>
  </details>
@@ -463,9 +461,18 @@ To solve these two problems we'll introduce some syntactic sugar. First some pre
 
 And now the sugar.
 
+> infixl 3 #
 > (#) :: (Num v) => v -> Quantity d v -> Quantity d v
 > v # (ValQuantity d bv) = ValQuantity d (v*bv)
 
+\ignore{
+
+> infixl 3 ##
+> (##) :: v -> Quantity d v -> Quantity d v
+> v ## (ValQuantity d _) = ValQuantity d v
+
+}
+
 The intended usage of the function is the following
 
 < ghci> let myDistance = 5 # length

Physics/src/Dimensions/QuantityExtended.hs

@@ -0,0 +1,202 @@
+
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE KindSignatures #-}
+
+{-# LANGUAGE MultiParamTypeClasses #-}
+
+module Dimensions.QuantityExtended where
+
+import qualified Dimensions.ValueLevel as V
+import           Dimensions.TypeLevel  as T
+import           Prelude               as P hiding (length)
+
+----------------------------------------
+-- Än så länge inget nytt
+----------------------------------------
+
+data Quantity (d :: T.Dim) (v :: *) where
+  ValQuantity :: V.Dim -> v -> Quantity d v
+
+showQuantity :: (Show v) => Quantity d v -> String
+showQuantity (ValQuantity d v) = show v ++ " " ++ show d
+
+instance (Show v) => Show (Quantity d v) where
+  show = showQuantity
+
+instance (Eq v) => Eq (Quantity d v) where
+  (ValQuantity _ v1) == (ValQuantity _ v2) = v1 == v2
+
+instance (Ord v) => Ord (Quantity d v) where
+  (ValQuantity _ v1) `compare` (ValQuantity _ v2) = v1 `compare` v2
+
+instance Functor (Quantity d) where
+  fmap f (ValQuantity d v) = ValQuantity d (f v)
+
+----------------------------------------
+-- Socker
+----------------------------------------
+
+infixl 3 ##
+(##) :: v -> Quantity d w -> Quantity d v
+v ## (ValQuantity d _) = ValQuantity d v
+
+-- Dummy-värden med matchande värde/typ-nivå dimensioner
+-- med en dummy-typ.
+
+length :: Quantity Length Double
+length = ValQuantity V.length 1.0
+mass :: Quantity Mass Double
+mass = ValQuantity V.mass 1.0
+time :: Quantity Time Double
+time = ValQuantity V.time 1.0
+
+-- Med `##` kan en Quantity med vilken värdetyp som helst skapas
+-- med valfri dimension av ovanstående.
+
+-- Om värdetypen ej stöder multiplikation och division kan
+-- dessa dummy-värden ändå göras så på, och därför kan man
+-- alltid få valfri dimension.
+
+----------------------------------------
+-- Aritmetik
+----------------------------------------
+
+-- En `Quantity` innehåller något av någon typ. Om och hur addition
+-- o.s.v. ser ut för den kan variera, så typen själv ska sköta det.
+-- Dessutom kan det var multiplikation mellan olika typer.
+
+class Addable a b c where
+  doAdd :: a -> b -> c
+
+(+#) :: (Addable a b c) => Quantity d a ->
+                           Quantity d b ->
+                           Quantity d c
+(ValQuantity d a) +# (ValQuantity _ b) = ValQuantity d $ doAdd a b
+
+-- Nedan går ej! Blir problem med Vector då. Vet ej varför.
+
+-- Allt "numeriskt" är adderbart
+--instance (Num v) => Addable v v v where
+--  doAdd = (+)
+
+----------
+
+class Subable a b c where
+  doSub :: a -> b -> c
+
+(-#) :: (Subable a b c) => Quantity d a ->
+                           Quantity d b ->
+                           Quantity d c
+(ValQuantity d a) -# (ValQuantity _ b) = ValQuantity d $ doSub a b
+
+--instance (Num v) => Subable v v v where
+--  doSub = (-)
+
+----------
+
+class Multiplicable a b c where
+  doMul :: a -> b -> c
+
+(*#) :: (Multiplicable a b c) => Quantity d1 a ->
+                                 Quantity d2 b ->
+                                 Quantity (d1 `Mul` d2) c
+(ValQuantity d1 a) *# (ValQuantity d2 b) = ValQuantity (d1 `V.mul` d2) $ doMul a b
+
+--instance (Num v) => Multiplicable v v v where
+--  doMul = (*)
+
+----------
+
+class Divisionable a b c where
+  doDiv :: a -> b -> c
+
+(/#) :: (Divisionable a b c) => Quantity d1 a ->
+                                Quantity d2 b ->
+                                Quantity (d1 `Div` d2) c
+(ValQuantity d1 a) /# (ValQuantity d2 b) = ValQuantity (d1 `V.div` d2) $ doDiv a b
+
+--instance (Fractional v) => Divisionable v v v where
+--  doMul = (*)
+
+----------------------------------------
+-- Derivering och integrering
+----------------------------------------
+
+-- Är själva grejen som finns i en Quantity deriverbar och
+-- integrerbar ska Quantityn med den i också vara det.
+
+class Differentiable a b where
+  doDif :: a -> b
+
+diff :: (Differentiable a b) => Quantity d a -> Quantity (d `Div` time) b
+diff = fmap doDif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+