{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE QuantifiedConstraints #-}

--------------------------------------------------------------------------------

-- |

--

-- Module      :  Data.Units.Base.System

-- Description :  System of units

-- Copyright   :  (c) Alice Rixte 2025

-- License     :  BSD 3

-- Maintainer  :  alice.rixte@u-bordeaux.fr

-- Stability   :  unstable

-- Portability :  non-portable (GHC extensions)

--

-- Describe a system of units and their dimensions.

--

--------------------------------------------------------------------------------


module Data.Units.Base.System
  (
  -- * Dimensions

    Dim
  , DimId
  , IsDim (..)
  , ShowDim (..)
  , prettysDim
  , showsDim
  , showDimOf
  , prettyDimOf
  , putDimOf
  , NormalizeDim

  -- * Units

  , Unit
  , ShowUnit (..)
  , prettysUnit
  , showsUnit
  , prettyUnitInfo
  , putInfoU
  , IsUnit (..)

  -- * Quantity

  , quantity
  , unQuantity
  , showQuantity
  , prettyQuantity
  , putQuantity
  , putInfoQ

  -- * Unit and dimension constructors

  , NoDim (..)
  , NoUnit (..)
  , MetaUnit (..)
  , type (.*.) (..)
  , type (.^.) (..)
  , type (.^+)
  , type (.^-)


  -- * Unit normalization

  , BaseUnitOf
  , NormalizeUnitL
  , NormalizeUnitR
  -- ** Normalization operators

  -- *** Multiplication

  , type (.*~)
  , type (~*.)
  , type (~*~)
  -- *** Division

  , type (./.)
  , type (./~)
  , type (~/.)
  , type (~/~)
  -- *** Exponentiation

  , type (~^.)
  , type (.^~)
  , type (~^~)
  )
  where

import Data.Coerce
import Data.Kind
import Data.Proxy
import Data.Type.Ord
import Data.Type.Bool
import Data.Type.Equality
import GHC.TypeError
import GHC.TypeLits

import Data.Type.Int


---------------------------------- Dimension -----------------------------------


-- | A unit dimension.

--

--  Modeled as a newtype constructor, just like @'Unit'@.

--

-- >>> type Speed = Length -/- Time

--

type Dim = Type -> Type

class (IsUnit (DimToUnit d), forall a. Coercible (d a) a)
  => IsDim (d :: Dim) where
  type DimToUnit d :: Unit

-- | A dimension identifier.

--

-- This identifiers allow to sort the units when computing the standard unit.

--

-- >>> type instance DimId Length = 300

--

-- >>> :kind! BaseUnitOf (Second .^- 1 .*. Meter)

-- Meter .*. (Second .^. Neg 1)

--

--

-- Two different dimensions must have different identifiers. To make sure this

-- remains true, we maintain here an /exhaustive/ list of dimensions declared

-- in this package /and/ any package that depends on it. Please raise an issue

-- if you added a new dimension.

--

-- [This package:]

--

--  +----------------------------------------------------+----------------+

--  | Dimension                                          | Id             |

--  +====================================================+================+

--  | Reserved                                           |   0            |

--  +----------------------------------------------------+----------------+

--  | @'NoDim'@                                          |   1            |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.AngleSI.System.Angle'@                | 1000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.Mass'@                      | 2000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.Length'@                    | 3000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.Time'@                      | 4000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.ElectricCurrent'@           | 5000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.Temperature'@               | 6000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.AmountOfSubstance'@         | 7000           |

--  +----------------------------------------------------+----------------+

--  | @'Data.Units.SI.System.LuminousIntensity'@         | 8000           |

--  +----------------------------------------------------+----------------+

--

type family DimId (d:: Dim) :: ZZ

-- | Dimensions that can be shown as a string, or as a type error message.

--

class ShowDim (d :: Dim) where
  {-# MINIMAL showDim |  showsDimPrec #-}

  -- | Allows to print dimensions in conversion error messages

  --

  -- >>> type ShowDimType Length = "L"

  --

  type ShowDimType d :: ErrorMessage

  -- | Convert a dimension to a readable string

  --

  -- @'showsDimPrec'@ should satisfy the law :

  --

  -- @showsDimPrec d x r ++ s  ==  showsPrec d x (r ++ s)@

  showsDimPrec :: Int -> ShowS
  showsDimPrec Int
_ = (forall (d :: Dim). ShowDim d => String
showDim @d String -> ShowS
forall a. [a] -> [a] -> [a]
++)

  -- | Convert a dimension to a string representing its type.

  --

  -- >>> showDim  @(Length ./. Time)

  -- "Length .*. Time.^-1"

  showDim :: String
  showDim = forall (d :: Dim). ShowDim d => ShowS
showsDim @d String
""

  -- | Same as @'showsDimPrec'@ but for pretty printing.

  --

  -- @'prettysDimPrec'@ should satisfy the law :

  --

  -- @prettysDimPrec d x r ++ s  ==  prettysPrec d x (r ++ s)@

  --

  prettysDimPrec :: Int -> ShowS
  prettysDimPrec Int
_ = (forall (d :: Dim). ShowDim d => String
prettyDim @d String -> ShowS
forall a. [a] -> [a] -> [a]
++)

  -- | Same as @'showDim'@ but for pretty printing

  --

  -- >>> putStrLn $ prettyDim @(Kilo Meter ./. Second)

  -- km.s⁻¹

  --

  prettyDim :: String
  prettyDim = forall (d :: Dim). ShowDim d => ShowS
prettysDim @d String
""

-- | Equivalent to 'showsDimPrec' with a precedence of 0.

--

showsDim :: forall d. ShowDim d => ShowS
showsDim :: forall (d :: Dim). ShowDim d => ShowS
showsDim = forall (d :: Dim). ShowDim d => Int -> ShowS
showsDimPrec @d Int
0

-- | Equivalent to 'prettysDimPrec' with a precedence of 0.

--

prettysDim :: forall d. ShowDim d => ShowS
prettysDim :: forall (d :: Dim). ShowDim d => ShowS
prettysDim = forall (d :: Dim). ShowDim d => Int -> ShowS
prettysDimPrec @d Int
0

-- | Show the dimension of a quantity.

--

-- >>>  showDimOf (quantity @(Kilo Meter ./. Second) 1)

-- "Length .*. Time.^-1"

--

showDimOf :: forall u a. (IsUnit u, ShowDim (DimOf u)) => u a -> String
showDimOf :: forall (u :: Dim) a. (IsUnit u, ShowDim (DimOf u)) => u a -> String
showDimOf u a
_ = forall (d :: Dim). ShowDim d => String
showDim @(DimOf u)

-- | Same as 'showDimOf' but for pretty printing.

-- >>> putStrLn $ prettyDimOf (quantity @(Kilo Meter ./. Second) 1)

-- L.T⁻¹

prettyDimOf :: forall u a. (IsUnit u, ShowDim (DimOf u)) => u a -> String
prettyDimOf :: forall (u :: Dim) a. (IsUnit u, ShowDim (DimOf u)) => u a -> String
prettyDimOf u a
_ = forall (d :: Dim). ShowDim d => String
prettyDim @(DimOf u)

-- | Print the dimension of a quantity.

--

-- >>> putDimOf (quantity @(Kilo Meter ./. Second) 1)

-- L.T⁻¹

--

putDimOf :: forall u a. (IsUnit u, ShowDim (DimOf u)) => u a -> IO ()
putDimOf :: forall (u :: Dim) a. (IsUnit u, ShowDim (DimOf u)) => u a -> IO ()
putDimOf = String -> IO ()
putStrLn (String -> IO ()) -> (u a -> String) -> u a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. u a -> String
forall (u :: Dim) a. (IsUnit u, ShowDim (DimOf u)) => u a -> String
prettyDimOf



-- | The dimension of non dimensional quantities

--

newtype NoDim a = NoDim a
  deriving ( Int -> NoDim a -> ShowS
[NoDim a] -> ShowS
NoDim a -> String
(Int -> NoDim a -> ShowS)
-> (NoDim a -> String) -> ([NoDim a] -> ShowS) -> Show (NoDim a)
forall a. Show a => Int -> NoDim a -> ShowS
forall a. Show a => [NoDim a] -> ShowS
forall a. Show a => NoDim a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> NoDim a -> ShowS
showsPrec :: Int -> NoDim a -> ShowS
$cshow :: forall a. Show a => NoDim a -> String
show :: NoDim a -> String
$cshowList :: forall a. Show a => [NoDim a] -> ShowS
showList :: [NoDim a] -> ShowS
Show, NoDim a -> NoDim a -> Bool
(NoDim a -> NoDim a -> Bool)
-> (NoDim a -> NoDim a -> Bool) -> Eq (NoDim a)
forall a. Eq a => NoDim a -> NoDim a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => NoDim a -> NoDim a -> Bool
== :: NoDim a -> NoDim a -> Bool
$c/= :: forall a. Eq a => NoDim a -> NoDim a -> Bool
/= :: NoDim a -> NoDim a -> Bool
Eq, Eq (NoDim a)
Eq (NoDim a) =>
(NoDim a -> NoDim a -> Ordering)
-> (NoDim a -> NoDim a -> Bool)
-> (NoDim a -> NoDim a -> Bool)
-> (NoDim a -> NoDim a -> Bool)
-> (NoDim a -> NoDim a -> Bool)
-> (NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a -> NoDim a)
-> Ord (NoDim a)
NoDim a -> NoDim a -> Bool
NoDim a -> NoDim a -> Ordering
NoDim a -> NoDim a -> NoDim a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (NoDim a)
forall a. Ord a => NoDim a -> NoDim a -> Bool
forall a. Ord a => NoDim a -> NoDim a -> Ordering
forall a. Ord a => NoDim a -> NoDim a -> NoDim a
$ccompare :: forall a. Ord a => NoDim a -> NoDim a -> Ordering
compare :: NoDim a -> NoDim a -> Ordering
$c< :: forall a. Ord a => NoDim a -> NoDim a -> Bool
< :: NoDim a -> NoDim a -> Bool
$c<= :: forall a. Ord a => NoDim a -> NoDim a -> Bool
<= :: NoDim a -> NoDim a -> Bool
$c> :: forall a. Ord a => NoDim a -> NoDim a -> Bool
> :: NoDim a -> NoDim a -> Bool
$c>= :: forall a. Ord a => NoDim a -> NoDim a -> Bool
>= :: NoDim a -> NoDim a -> Bool
$cmax :: forall a. Ord a => NoDim a -> NoDim a -> NoDim a
max :: NoDim a -> NoDim a -> NoDim a
$cmin :: forall a. Ord a => NoDim a -> NoDim a -> NoDim a
min :: NoDim a -> NoDim a -> NoDim a
Ord, Integer -> NoDim a
NoDim a -> NoDim a
NoDim a -> NoDim a -> NoDim a
(NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (Integer -> NoDim a)
-> Num (NoDim a)
forall a. Num a => Integer -> NoDim a
forall a. Num a => NoDim a -> NoDim a
forall a. Num a => NoDim a -> NoDim a -> NoDim a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => NoDim a -> NoDim a -> NoDim a
+ :: NoDim a -> NoDim a -> NoDim a
$c- :: forall a. Num a => NoDim a -> NoDim a -> NoDim a
- :: NoDim a -> NoDim a -> NoDim a
$c* :: forall a. Num a => NoDim a -> NoDim a -> NoDim a
* :: NoDim a -> NoDim a -> NoDim a
$cnegate :: forall a. Num a => NoDim a -> NoDim a
negate :: NoDim a -> NoDim a
$cabs :: forall a. Num a => NoDim a -> NoDim a
abs :: NoDim a -> NoDim a
$csignum :: forall a. Num a => NoDim a -> NoDim a
signum :: NoDim a -> NoDim a
$cfromInteger :: forall a. Num a => Integer -> NoDim a
fromInteger :: Integer -> NoDim a
Num, Num (NoDim a)
Num (NoDim a) =>
(NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (Rational -> NoDim a)
-> Fractional (NoDim a)
Rational -> NoDim a
NoDim a -> NoDim a
NoDim a -> NoDim a -> NoDim a
forall a. Fractional a => Num (NoDim a)
forall a. Fractional a => Rational -> NoDim a
forall a. Fractional a => NoDim a -> NoDim a
forall a. Fractional a => NoDim a -> NoDim a -> NoDim a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a. Fractional a => NoDim a -> NoDim a -> NoDim a
/ :: NoDim a -> NoDim a -> NoDim a
$crecip :: forall a. Fractional a => NoDim a -> NoDim a
recip :: NoDim a -> NoDim a
$cfromRational :: forall a. Fractional a => Rational -> NoDim a
fromRational :: Rational -> NoDim a
Fractional, Fractional (NoDim a)
NoDim a
Fractional (NoDim a) =>
NoDim a
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> Floating (NoDim a)
NoDim a -> NoDim a
NoDim a -> NoDim a -> NoDim a
forall a. Floating a => Fractional (NoDim a)
forall a. Floating a => NoDim a
forall a. Floating a => NoDim a -> NoDim a
forall a. Floating a => NoDim a -> NoDim a -> NoDim a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
$cpi :: forall a. Floating a => NoDim a
pi :: NoDim a
$cexp :: forall a. Floating a => NoDim a -> NoDim a
exp :: NoDim a -> NoDim a
$clog :: forall a. Floating a => NoDim a -> NoDim a
log :: NoDim a -> NoDim a
$csqrt :: forall a. Floating a => NoDim a -> NoDim a
sqrt :: NoDim a -> NoDim a
$c** :: forall a. Floating a => NoDim a -> NoDim a -> NoDim a
** :: NoDim a -> NoDim a -> NoDim a
$clogBase :: forall a. Floating a => NoDim a -> NoDim a -> NoDim a
logBase :: NoDim a -> NoDim a -> NoDim a
$csin :: forall a. Floating a => NoDim a -> NoDim a
sin :: NoDim a -> NoDim a
$ccos :: forall a. Floating a => NoDim a -> NoDim a
cos :: NoDim a -> NoDim a
$ctan :: forall a. Floating a => NoDim a -> NoDim a
tan :: NoDim a -> NoDim a
$casin :: forall a. Floating a => NoDim a -> NoDim a
asin :: NoDim a -> NoDim a
$cacos :: forall a. Floating a => NoDim a -> NoDim a
acos :: NoDim a -> NoDim a
$catan :: forall a. Floating a => NoDim a -> NoDim a
atan :: NoDim a -> NoDim a
$csinh :: forall a. Floating a => NoDim a -> NoDim a
sinh :: NoDim a -> NoDim a
$ccosh :: forall a. Floating a => NoDim a -> NoDim a
cosh :: NoDim a -> NoDim a
$ctanh :: forall a. Floating a => NoDim a -> NoDim a
tanh :: NoDim a -> NoDim a
$casinh :: forall a. Floating a => NoDim a -> NoDim a
asinh :: NoDim a -> NoDim a
$cacosh :: forall a. Floating a => NoDim a -> NoDim a
acosh :: NoDim a -> NoDim a
$catanh :: forall a. Floating a => NoDim a -> NoDim a
atanh :: NoDim a -> NoDim a
$clog1p :: forall a. Floating a => NoDim a -> NoDim a
log1p :: NoDim a -> NoDim a
$cexpm1 :: forall a. Floating a => NoDim a -> NoDim a
expm1 :: NoDim a -> NoDim a
$clog1pexp :: forall a. Floating a => NoDim a -> NoDim a
log1pexp :: NoDim a -> NoDim a
$clog1mexp :: forall a. Floating a => NoDim a -> NoDim a
log1mexp :: NoDim a -> NoDim a
Floating, Num (NoDim a)
Ord (NoDim a)
(Num (NoDim a), Ord (NoDim a)) =>
(NoDim a -> Rational) -> Real (NoDim a)
NoDim a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall a. Real a => Num (NoDim a)
forall a. Real a => Ord (NoDim a)
forall a. Real a => NoDim a -> Rational
$ctoRational :: forall a. Real a => NoDim a -> Rational
toRational :: NoDim a -> Rational
Real
           , Fractional (NoDim a)
Real (NoDim a)
(Real (NoDim a), Fractional (NoDim a)) =>
(forall b. Integral b => NoDim a -> (b, NoDim a))
-> (forall b. Integral b => NoDim a -> b)
-> (forall b. Integral b => NoDim a -> b)
-> (forall b. Integral b => NoDim a -> b)
-> (forall b. Integral b => NoDim a -> b)
-> RealFrac (NoDim a)
forall b. Integral b => NoDim a -> b
forall b. Integral b => NoDim a -> (b, NoDim a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall a. RealFrac a => Fractional (NoDim a)
forall a. RealFrac a => Real (NoDim a)
forall a b. (RealFrac a, Integral b) => NoDim a -> b
forall a b. (RealFrac a, Integral b) => NoDim a -> (b, NoDim a)
$cproperFraction :: forall a b. (RealFrac a, Integral b) => NoDim a -> (b, NoDim a)
properFraction :: forall b. Integral b => NoDim a -> (b, NoDim a)
$ctruncate :: forall a b. (RealFrac a, Integral b) => NoDim a -> b
truncate :: forall b. Integral b => NoDim a -> b
$cround :: forall a b. (RealFrac a, Integral b) => NoDim a -> b
round :: forall b. Integral b => NoDim a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => NoDim a -> b
ceiling :: forall b. Integral b => NoDim a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => NoDim a -> b
floor :: forall b. Integral b => NoDim a -> b
RealFrac, Floating (NoDim a)
RealFrac (NoDim a)
(RealFrac (NoDim a), Floating (NoDim a)) =>
(NoDim a -> Integer)
-> (NoDim a -> Int)
-> (NoDim a -> (Int, Int))
-> (NoDim a -> (Integer, Int))
-> (Integer -> Int -> NoDim a)
-> (NoDim a -> Int)
-> (NoDim a -> NoDim a)
-> (Int -> NoDim a -> NoDim a)
-> (NoDim a -> Bool)
-> (NoDim a -> Bool)
-> (NoDim a -> Bool)
-> (NoDim a -> Bool)
-> (NoDim a -> Bool)
-> (NoDim a -> NoDim a -> NoDim a)
-> RealFloat (NoDim a)
Int -> NoDim a -> NoDim a
Integer -> Int -> NoDim a
NoDim a -> Bool
NoDim a -> Int
NoDim a -> Integer
NoDim a -> (Int, Int)
NoDim a -> (Integer, Int)
NoDim a -> NoDim a
NoDim a -> NoDim a -> NoDim a
forall a. RealFloat a => Floating (NoDim a)
forall a. RealFloat a => RealFrac (NoDim a)
forall a. RealFloat a => Int -> NoDim a -> NoDim a
forall a. RealFloat a => Integer -> Int -> NoDim a
forall a. RealFloat a => NoDim a -> Bool
forall a. RealFloat a => NoDim a -> Int
forall a. RealFloat a => NoDim a -> Integer
forall a. RealFloat a => NoDim a -> (Int, Int)
forall a. RealFloat a => NoDim a -> (Integer, Int)
forall a. RealFloat a => NoDim a -> NoDim a
forall a. RealFloat a => NoDim a -> NoDim a -> NoDim a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
$cfloatRadix :: forall a. RealFloat a => NoDim a -> Integer
floatRadix :: NoDim a -> Integer
$cfloatDigits :: forall a. RealFloat a => NoDim a -> Int
floatDigits :: NoDim a -> Int
$cfloatRange :: forall a. RealFloat a => NoDim a -> (Int, Int)
floatRange :: NoDim a -> (Int, Int)
$cdecodeFloat :: forall a. RealFloat a => NoDim a -> (Integer, Int)
decodeFloat :: NoDim a -> (Integer, Int)
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> NoDim a
encodeFloat :: Integer -> Int -> NoDim a
$cexponent :: forall a. RealFloat a => NoDim a -> Int
exponent :: NoDim a -> Int
$csignificand :: forall a. RealFloat a => NoDim a -> NoDim a
significand :: NoDim a -> NoDim a
$cscaleFloat :: forall a. RealFloat a => Int -> NoDim a -> NoDim a
scaleFloat :: Int -> NoDim a -> NoDim a
$cisNaN :: forall a. RealFloat a => NoDim a -> Bool
isNaN :: NoDim a -> Bool
$cisInfinite :: forall a. RealFloat a => NoDim a -> Bool
isInfinite :: NoDim a -> Bool
$cisDenormalized :: forall a. RealFloat a => NoDim a -> Bool
isDenormalized :: NoDim a -> Bool
$cisNegativeZero :: forall a. RealFloat a => NoDim a -> Bool
isNegativeZero :: NoDim a -> Bool
$cisIEEE :: forall a. RealFloat a => NoDim a -> Bool
isIEEE :: NoDim a -> Bool
$catan2 :: forall a. RealFloat a => NoDim a -> NoDim a -> NoDim a
atan2 :: NoDim a -> NoDim a -> NoDim a
RealFloat, NoDim a
NoDim a -> NoDim a -> Bounded (NoDim a)
forall a. a -> a -> Bounded a
forall a. Bounded a => NoDim a
$cminBound :: forall a. Bounded a => NoDim a
minBound :: NoDim a
$cmaxBound :: forall a. Bounded a => NoDim a
maxBound :: NoDim a
Bounded, Int -> NoDim a
NoDim a -> Int
NoDim a -> [NoDim a]
NoDim a -> NoDim a
NoDim a -> NoDim a -> [NoDim a]
NoDim a -> NoDim a -> NoDim a -> [NoDim a]
(NoDim a -> NoDim a)
-> (NoDim a -> NoDim a)
-> (Int -> NoDim a)
-> (NoDim a -> Int)
-> (NoDim a -> [NoDim a])
-> (NoDim a -> NoDim a -> [NoDim a])
-> (NoDim a -> NoDim a -> [NoDim a])
-> (NoDim a -> NoDim a -> NoDim a -> [NoDim a])
-> Enum (NoDim a)
forall a. Enum a => Int -> NoDim a
forall a. Enum a => NoDim a -> Int
forall a. Enum a => NoDim a -> [NoDim a]
forall a. Enum a => NoDim a -> NoDim a
forall a. Enum a => NoDim a -> NoDim a -> [NoDim a]
forall a. Enum a => NoDim a -> NoDim a -> NoDim a -> [NoDim a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: forall a. Enum a => NoDim a -> NoDim a
succ :: NoDim a -> NoDim a
$cpred :: forall a. Enum a => NoDim a -> NoDim a
pred :: NoDim a -> NoDim a
$ctoEnum :: forall a. Enum a => Int -> NoDim a
toEnum :: Int -> NoDim a
$cfromEnum :: forall a. Enum a => NoDim a -> Int
fromEnum :: NoDim a -> Int
$cenumFrom :: forall a. Enum a => NoDim a -> [NoDim a]
enumFrom :: NoDim a -> [NoDim a]
$cenumFromThen :: forall a. Enum a => NoDim a -> NoDim a -> [NoDim a]
enumFromThen :: NoDim a -> NoDim a -> [NoDim a]
$cenumFromTo :: forall a. Enum a => NoDim a -> NoDim a -> [NoDim a]
enumFromTo :: NoDim a -> NoDim a -> [NoDim a]
$cenumFromThenTo :: forall a. Enum a => NoDim a -> NoDim a -> NoDim a -> [NoDim a]
enumFromThenTo :: NoDim a -> NoDim a -> NoDim a -> [NoDim a]
Enum, NonEmpty (NoDim a) -> NoDim a
NoDim a -> NoDim a -> NoDim a
(NoDim a -> NoDim a -> NoDim a)
-> (NonEmpty (NoDim a) -> NoDim a)
-> (forall b. Integral b => b -> NoDim a -> NoDim a)
-> Semigroup (NoDim a)
forall b. Integral b => b -> NoDim a -> NoDim a
forall a. Semigroup a => NonEmpty (NoDim a) -> NoDim a
forall a. Semigroup a => NoDim a -> NoDim a -> NoDim a
forall a b. (Semigroup a, Integral b) => b -> NoDim a -> NoDim a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: forall a. Semigroup a => NoDim a -> NoDim a -> NoDim a
<> :: NoDim a -> NoDim a -> NoDim a
$csconcat :: forall a. Semigroup a => NonEmpty (NoDim a) -> NoDim a
sconcat :: NonEmpty (NoDim a) -> NoDim a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> NoDim a -> NoDim a
stimes :: forall b. Integral b => b -> NoDim a -> NoDim a
Semigroup, Semigroup (NoDim a)
NoDim a
Semigroup (NoDim a) =>
NoDim a
-> (NoDim a -> NoDim a -> NoDim a)
-> ([NoDim a] -> NoDim a)
-> Monoid (NoDim a)
[NoDim a] -> NoDim a
NoDim a -> NoDim a -> NoDim a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (NoDim a)
forall a. Monoid a => NoDim a
forall a. Monoid a => [NoDim a] -> NoDim a
forall a. Monoid a => NoDim a -> NoDim a -> NoDim a
$cmempty :: forall a. Monoid a => NoDim a
mempty :: NoDim a
$cmappend :: forall a. Monoid a => NoDim a -> NoDim a -> NoDim a
mappend :: NoDim a -> NoDim a -> NoDim a
$cmconcat :: forall a. Monoid a => [NoDim a] -> NoDim a
mconcat :: [NoDim a] -> NoDim a
Monoid, (forall a b. (a -> b) -> NoDim a -> NoDim b)
-> (forall a b. a -> NoDim b -> NoDim a) -> Functor NoDim
forall a b. a -> NoDim b -> NoDim a
forall a b. (a -> b) -> NoDim a -> NoDim b
forall (f :: Dim).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> NoDim a -> NoDim b
fmap :: forall a b. (a -> b) -> NoDim a -> NoDim b
$c<$ :: forall a b. a -> NoDim b -> NoDim a
<$ :: forall a b. a -> NoDim b -> NoDim a
Functor)


type instance DimId NoDim = Pos 1

instance ShowDim NoDim where
  type ShowDimType NoDim = Text "NoDim"
  showDim :: String
showDim = String
"NoDim"
  prettyDim :: String
prettyDim = String
"NoDim"


type family CmpDim (d :: Dim) (e :: Dim) :: Ordering where
  CmpDim (d .*. d') (e .*. e') =
    If (CmpDim d e == 'EQ) (CmpDim d' e') (CmpDim d e)
  CmpDim (d .*. d') e ='LT
  CmpDim d (e .*. e') = 'GT
  CmpDim (d .^. dn) (e .^. en) =
    If (CmpDim d e == 'EQ) (CmpSigned dn en) (CmpDim d e)
  CmpDim (d .^. dn) e =
    If (CmpDim d e == 'EQ) (CmpSigned dn (Pos 1)) (CmpDim d e)
  CmpDim d (e .^. en) =
    If (CmpDim d e == 'EQ) (CmpSigned (Pos 1) en) (CmpDim d e)
  CmpDim d e = CmpSigned (DimId d) (DimId e)


-------------------------- Dimension normalization ---------------------------



-- | Helper type family for defining DimOf for .*. and .^.

--

type family DimOf' (u :: Unit) :: Dim where
  DimOf' u = NormalizeDim (UnitToDim u)

type family UnitToDim (u :: Unit) :: Dim where
  UnitToDim (u .*. v) = UnitToDim u .*. UnitToDim v
  UnitToDim (u .^. n) = UnitToDim u .^. n
  UnitToDim u = DimOf u

type NormalizeDim d = NormalizeFlatDim (Flatten d)

type family Flatten u where
  Flatten (u .*. v) = Flatten u .*. Flatten v
  Flatten ((u .*. v) .^. n) = Flatten (u .^. n) .*. Flatten (v .^. n)
  Flatten ((u .^. n) .^. m) = Flatten (u .^. Mul n m)
  Flatten (u .^. n) = u .^. n
  Flatten u = u

type family NormalizeFlatDim d where
  NormalizeFlatDim (d .*. NoDim) = NormalizeFlatDim d
  NormalizeFlatDim (NoDim .*. e) = NormalizeFlatDim e
  NormalizeFlatDim ((d .*. e) .*. f) = NormalizeFlatDim (d .*. (e .*. f))
  NormalizeFlatDim (d .*. e) =
    InsertDim (NormalizeFlatDim d) (NormalizeFlatDim e)
  NormalizeFlatDim (NoDim .^. n) = NoDim
  NormalizeFlatDim (d .^. n) = NormalizeExpDim (d .^. n)
  NormalizeFlatDim d = d

type family InsertDim d e where
  InsertDim NoDim e = e
  InsertDim d NoDim = d
  InsertDim d (e .*. f) =
    InsertCmpDim (Compare (DimId d) (DimId e)) d (e .*. f)
  InsertDim d e =
    InsertCmpDim (Compare (DimId d) (DimId e)) d e

type family InsertCmpDim cmp d v where
  InsertCmpDim 'LT d (e .*. f) = d .*. e .*. f
  InsertCmpDim 'GT d (e .*. f) = e .*. InsertDim d f
  InsertCmpDim 'EQ d (e .*. f) = MulNoDim (MulPowDim d e) f
  InsertCmpDim 'LT d e = d .*. e
  InsertCmpDim 'GT d e = e .*. d
  InsertCmpDim 'EQ d e = MulPowDim d e

type family MulNoDim d e where
  MulNoDim NoDim e = e
  MulNoDim d NoDim = d
  MulNoDim d e = d .*. e

type family MulPowDim d e where
  MulPowDim (d .^. n) (d .^. m) = NormalizeExpDim (d .^. Add n m)
  MulPowDim d (d .^. m) = NormalizeExpDim (d .^. Add (Pos 1) m)
  MulPowDim (d .^. n) d = NormalizeExpDim (d .^. Add n (Pos 1))
  MulPowDim d d = d .^. Pos 2
  MulPowDim d e = TypeError (
         Text "Failed to multiply two different units ‘"
    :<>: ShowUnitType d
    :<>: Text "’ and ‘"
    :<>: ShowUnitType e
    :<>: Text "’ with the same dimension ‘"
    :<>: ShowDimType (DimOf d)
    :<>: Text "’."
    :$$: Text "Hint : Did you try to multiply via (.*.) two quantities with"
    :$$: Text "       the same dimension but different units ?"
    :$$: Text "If so, you might want to use (~*-), (-*~) or (~*~) instead. "
    )

type family NormalizeExpDim u where
  NormalizeExpDim (u .^. Pos 1) = u
  NormalizeExpDim (u .^. Zero) = NoDim
  NormalizeExpDim u = u


------------------------------------ Units -------------------------------------


-- | A unit is represented by a newtype constructor. A quantity of some unit

-- @u@ is of type @u a@.

--

type Unit = Type -> Type

-- | Any unit must have a dimension. Additionally, a unit is a newtype

-- constructor : a quantity @u a@ can always be coerced to its magnitude @a@.

--

class (forall a. Coercible (u a) a) => IsUnit (u :: Unit) where
  type DimOf u :: Dim

-- | Make a quantity out of any numerical value (called the /magnitude/ of that

-- quantity)

--

-- >>> quantity @(Meter ./. Second) 1

-- quantity @(Meter .*. Second .^- 1) 1

quantity :: forall u a. IsUnit u => a -> u a
quantity :: forall (u :: Dim) a. IsUnit u => a -> u a
quantity = a -> u a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE quantity #-}

-- | Get the magnitude of a quantity.

--

--  @unQuantity (quantity @u a) === a @

--

unQuantity :: IsUnit u => u a -> a
unQuantity :: forall (u :: Dim) a. IsUnit u => u a -> a
unQuantity = u a -> a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE unQuantity #-}

-- | Units that can be shown as a string, or as a type error message.

--

class IsUnit u => ShowUnit (u :: Unit) where
  {-# MINIMAL showUnit |  showsUnitPrec #-}

  -- | Allows to print units in conversion error messages

  --

  -- >>> type ShowUnit Meter = "m"

  --

  type ShowUnitType u :: ErrorMessage

  -- | Convert a unit to a readable string

  --

  -- @'showsUnitPrec'@ should satisfy the law :

  --

  -- @showsUnitPrec d x r ++ s  ==  showsPrec d x (r ++ s)@

  --

  showsUnitPrec :: Int -> ShowS
  showsUnitPrec Int
_ = (forall (u :: Dim). ShowUnit u => String
showUnit @u String -> ShowS
forall a. [a] -> [a] -> [a]
++)

  -- | Convert a unit to a string representing its type.

  --

  -- >>> showUnit @(Kilo Meter ./. Second)

  -- "Kilo Meter .*. Second.^-1"

  showUnit :: String
  showUnit = forall (u :: Dim). ShowUnit u => ShowS
showsUnit @u String
""

  -- | Same as @'showsUnitPrec'@ but for pretty printing.

  --

  prettysUnitPrec :: Int -> ShowS
  prettysUnitPrec Int
_ = (forall (u :: Dim). ShowUnit u => String
prettyUnit @u String -> ShowS
forall a. [a] -> [a] -> [a]
++)

  -- | Same as @'showUnit'@ but for pretty printing

  --

  -- >>> putStrLn $ prettyUnit @(Kilo Meter ./. Second)

  -- km.s⁻¹

  --

  prettyUnit :: String
  prettyUnit = forall (u :: Dim). ShowUnit u => ShowS
prettysUnit @u String
""


-- | Equivalent to 'showsUnitPrec' with a precedence of 0.

--

showsUnit :: forall u. ShowUnit u => ShowS
showsUnit :: forall (u :: Dim). ShowUnit u => ShowS
showsUnit = forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @u Int
0

-- | Equivalent to 'prettysUnitPrec' with a precedence of 0.

--

prettysUnit :: forall u. ShowUnit u => ShowS
prettysUnit :: forall (u :: Dim). ShowUnit u => ShowS
prettysUnit = forall (u :: Dim). ShowUnit u => Int -> ShowS
prettysUnitPrec @u Int
0

-- | Pretty print information about a unit, its dimension and its normalized

-- form.

--

prettyUnitInfo :: forall u du nu.
  ( du ~ DimOf u
  , nu ~ BaseUnitOf u
  , ShowUnit u
  , ShowDim du
  , ShowUnit nu
  ) => String
prettyUnitInfo :: forall (u :: Dim) (du :: Dim) (nu :: Dim).
(du ~ DimOf u, nu ~ BaseUnitOf u, ShowUnit u, ShowDim du,
 ShowUnit nu) =>
String
prettyUnitInfo =
  String
"Unit:       " String -> ShowS
forall a. [a] -> [a] -> [a]
++ forall (u :: Dim). ShowUnit u => String
showUnit @u  String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++
  String
" abbr:      " String -> ShowS
forall a. [a] -> [a] -> [a]
++ forall (u :: Dim). ShowUnit u => String
prettyUnit @u  String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++
  String
"Dimension:  " String -> ShowS
forall a. [a] -> [a] -> [a]
++ forall (d :: Dim). ShowDim d => String
showDim @du  String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++
  String
" abbr:      " String -> ShowS
forall a. [a] -> [a] -> [a]
++ forall (d :: Dim). ShowDim d => String
prettyDim @du  String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++
  String
"Normalized: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ forall (u :: Dim). ShowUnit u => String
showUnit @nu String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++
  String
" abbr:      " String -> ShowS
forall a. [a] -> [a] -> [a]
++ forall (u :: Dim). ShowUnit u => String
prettyUnit @nu String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n"

-- | Print information about a unit, its dimension and its normalized form.

--

-- >>> putInfoU @Newton

-- Unit:       Newton

--  abbr:      N

-- Dimension:  Mass .*. Length .*. Time.^-2

--  abbr:      M⋅L⋅T⁻²

-- Normalized: Kilo Gram .*. Meter .*. Second.^-2

--  abbr:      kg⋅m⋅s⁻²

--

putInfoU :: forall u du nu.
  ( du ~ DimOf u
  , nu ~ BaseUnitOf u
  , ShowUnit u
  , ShowDim du
  , ShowUnit nu
  ) => IO ()
putInfoU :: forall (u :: Dim) (du :: Dim) (nu :: Dim).
(du ~ DimOf u, nu ~ BaseUnitOf u, ShowUnit u, ShowDim du,
 ShowUnit nu) =>
IO ()
putInfoU = String -> IO ()
putStr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ forall (u :: Dim) (du :: Dim) (nu :: Dim).
(du ~ DimOf u, nu ~ BaseUnitOf u, ShowUnit u, ShowDim du,
 ShowUnit nu) =>
String
prettyUnitInfo @u

-- | Same as 'prettyUnitInfo' but for quantities.

--

prettyQuantityInfo :: forall u a.
  ( ShowUnit u
  , ShowDim (DimOf u)
  , ShowUnit (BaseUnitOf u)
  , Show a
  ) => u a -> String
prettyQuantityInfo :: forall (u :: Dim) a.
(ShowUnit u, ShowDim (DimOf u), ShowUnit (BaseUnitOf u), Show a) =>
u a -> String
prettyQuantityInfo u a
u = forall (u :: Dim) (du :: Dim) (nu :: Dim).
(du ~ DimOf u, nu ~ BaseUnitOf u, ShowUnit u, ShowDim du,
 ShowUnit nu) =>
String
prettyUnitInfo @u String -> ShowS
forall a. [a] -> [a] -> [a]
++
  String
"Magnitude:  " String -> ShowS
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show (u a -> a
forall (u :: Dim) a. IsUnit u => u a -> a
unQuantity u a
u) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n"

-- | Same as 'putInfoU' but for quantities.

--

-- >>> putInfoQ (Newton 4)

-- Unit:       Newton

--  abbr:      N

-- Dimension:  Mass .*. Length .*. Time.^-2

--  abbr:      M⋅L⋅T⁻²

-- Normalized: Kilo Gram .*. Meter .*. Second.^-2

--  abbr:      kg⋅m⋅s⁻²

-- Magnitude:  4

putInfoQ :: forall u a.
  ( ShowUnit u
  , ShowDim (DimOf u)
  , ShowUnit (BaseUnitOf u)
  , Show a
  ) => u a -> IO ()
putInfoQ :: forall (u :: Dim) a.
(ShowUnit u, ShowDim (DimOf u), ShowUnit (BaseUnitOf u), Show a) =>
u a -> IO ()
putInfoQ u a
u = String -> IO ()
putStr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ forall (u :: Dim) a.
(ShowUnit u, ShowDim (DimOf u), ShowUnit (BaseUnitOf u), Show a) =>
u a -> String
prettyQuantityInfo @u u a
u


-- | Same as 'showsUnitPrec' but for quantities.

--

showsQuantityPrec :: forall u a. (ShowUnit u, Show a) => Int -> u a -> ShowS
showsQuantityPrec :: forall (u :: Dim) a. (ShowUnit u, Show a) => Int -> u a -> ShowS
showsQuantityPrec Int
d u a
u = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    String -> ShowS
showString String
"quantity @" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @u Int
11 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      Int -> a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 (u a -> a
forall (u :: Dim) a. IsUnit u => u a -> a
unQuantity u a
u)

-- | Equivalent to 'showsQuantityPrec' with a precedence of 0.

--

showsQuantity :: (ShowUnit u, Show a) => u a -> ShowS
showsQuantity :: forall (u :: Dim) a. (ShowUnit u, Show a) => u a -> ShowS
showsQuantity  = Int -> u a -> ShowS
forall (u :: Dim) a. (ShowUnit u, Show a) => Int -> u a -> ShowS
showsQuantityPrec Int
0

-- | Same as 'showUnit' but for quantities

--

-- >>> showQuantity (quantity @(Kilo Meter ./. Second) 1)

-- "quantity @(Kilo Meter .*. Second.^-1) 1.0"

--

showQuantity :: (ShowUnit u, Show a) => u a -> String
showQuantity :: forall (u :: Dim) a. (ShowUnit u, Show a) => u a -> String
showQuantity u a
u = u a -> ShowS
forall (u :: Dim) a. (ShowUnit u, Show a) => u a -> ShowS
showsQuantity u a
u String
""

-- | Same as 'prettyUnit' but for quantities

--

-- >>> putStrLn $ prettyQuantity (quantity @(Kilo Meter ./. Second) 1)

-- 1 km.s⁻¹

--

prettyQuantity :: forall u a. (ShowUnit u, Show a) => u a -> String
prettyQuantity :: forall (u :: Dim) a. (ShowUnit u, Show a) => u a -> String
prettyQuantity u a
u  = a -> String
forall a. Show a => a -> String
show (u a -> a
forall (u :: Dim) a. IsUnit u => u a -> a
unQuantity u a
u) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++  forall (u :: Dim). ShowUnit u => String
prettyUnit @u

-- | Pretty print a quantity.

--

-- >>> putQuantity (quantity @(Kilo Meter ./. Second) 1)

-- 1 km.s⁻¹

putQuantity :: (Show a, ShowUnit u) => u a -> IO ()
putQuantity :: forall a (u :: Dim). (Show a, ShowUnit u) => u a -> IO ()
putQuantity = String -> IO ()
putStrLn (String -> IO ()) -> (u a -> String) -> u a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. u a -> String
forall (u :: Dim) a. (ShowUnit u, Show a) => u a -> String
prettyQuantity


--------------------------------------------------------------------------------



-- | A unit that can represent any unit.

--

-- This can be used with the `deriving via` mechanism to derive some of the

-- unit instances.

--

newtype MetaUnit (u :: Unit) a = MetaUnit a
  deriving ( MetaUnit u a -> MetaUnit u a -> Bool
(MetaUnit u a -> MetaUnit u a -> Bool)
-> (MetaUnit u a -> MetaUnit u a -> Bool) -> Eq (MetaUnit u a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (u :: Dim) a. Eq a => MetaUnit u a -> MetaUnit u a -> Bool
$c== :: forall (u :: Dim) a. Eq a => MetaUnit u a -> MetaUnit u a -> Bool
== :: MetaUnit u a -> MetaUnit u a -> Bool
$c/= :: forall (u :: Dim) a. Eq a => MetaUnit u a -> MetaUnit u a -> Bool
/= :: MetaUnit u a -> MetaUnit u a -> Bool
Eq, Eq (MetaUnit u a)
Eq (MetaUnit u a) =>
(MetaUnit u a -> MetaUnit u a -> Ordering)
-> (MetaUnit u a -> MetaUnit u a -> Bool)
-> (MetaUnit u a -> MetaUnit u a -> Bool)
-> (MetaUnit u a -> MetaUnit u a -> Bool)
-> (MetaUnit u a -> MetaUnit u a -> Bool)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> Ord (MetaUnit u a)
MetaUnit u a -> MetaUnit u a -> Bool
MetaUnit u a -> MetaUnit u a -> Ordering
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (u :: Dim) a. Ord a => Eq (MetaUnit u a)
forall (u :: Dim) a. Ord a => MetaUnit u a -> MetaUnit u a -> Bool
forall (u :: Dim) a.
Ord a =>
MetaUnit u a -> MetaUnit u a -> Ordering
forall (u :: Dim) a.
Ord a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$ccompare :: forall (u :: Dim) a.
Ord a =>
MetaUnit u a -> MetaUnit u a -> Ordering
compare :: MetaUnit u a -> MetaUnit u a -> Ordering
$c< :: forall (u :: Dim) a. Ord a => MetaUnit u a -> MetaUnit u a -> Bool
< :: MetaUnit u a -> MetaUnit u a -> Bool
$c<= :: forall (u :: Dim) a. Ord a => MetaUnit u a -> MetaUnit u a -> Bool
<= :: MetaUnit u a -> MetaUnit u a -> Bool
$c> :: forall (u :: Dim) a. Ord a => MetaUnit u a -> MetaUnit u a -> Bool
> :: MetaUnit u a -> MetaUnit u a -> Bool
$c>= :: forall (u :: Dim) a. Ord a => MetaUnit u a -> MetaUnit u a -> Bool
>= :: MetaUnit u a -> MetaUnit u a -> Bool
$cmax :: forall (u :: Dim) a.
Ord a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
max :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$cmin :: forall (u :: Dim) a.
Ord a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
min :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
Ord, Integer -> MetaUnit u a
MetaUnit u a -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
(MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (Integer -> MetaUnit u a)
-> Num (MetaUnit u a)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall (u :: Dim) a. Num a => Integer -> MetaUnit u a
forall (u :: Dim) a. Num a => MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a.
Num a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$c+ :: forall (u :: Dim) a.
Num a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
+ :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$c- :: forall (u :: Dim) a.
Num a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
- :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$c* :: forall (u :: Dim) a.
Num a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
* :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$cnegate :: forall (u :: Dim) a. Num a => MetaUnit u a -> MetaUnit u a
negate :: MetaUnit u a -> MetaUnit u a
$cabs :: forall (u :: Dim) a. Num a => MetaUnit u a -> MetaUnit u a
abs :: MetaUnit u a -> MetaUnit u a
$csignum :: forall (u :: Dim) a. Num a => MetaUnit u a -> MetaUnit u a
signum :: MetaUnit u a -> MetaUnit u a
$cfromInteger :: forall (u :: Dim) a. Num a => Integer -> MetaUnit u a
fromInteger :: Integer -> MetaUnit u a
Num, Num (MetaUnit u a)
Num (MetaUnit u a) =>
(MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (Rational -> MetaUnit u a)
-> Fractional (MetaUnit u a)
Rational -> MetaUnit u a
MetaUnit u a -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall (u :: Dim) a. Fractional a => Num (MetaUnit u a)
forall (u :: Dim) a. Fractional a => Rational -> MetaUnit u a
forall (u :: Dim) a. Fractional a => MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a.
Fractional a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$c/ :: forall (u :: Dim) a.
Fractional a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
/ :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$crecip :: forall (u :: Dim) a. Fractional a => MetaUnit u a -> MetaUnit u a
recip :: MetaUnit u a -> MetaUnit u a
$cfromRational :: forall (u :: Dim) a. Fractional a => Rational -> MetaUnit u a
fromRational :: Rational -> MetaUnit u a
Fractional, Fractional (MetaUnit u a)
MetaUnit u a
Fractional (MetaUnit u a) =>
MetaUnit u a
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> Floating (MetaUnit u a)
MetaUnit u a -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
forall (u :: Dim) a. Floating a => Fractional (MetaUnit u a)
forall (u :: Dim) a. Floating a => MetaUnit u a
forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a.
Floating a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$cpi :: forall (u :: Dim) a. Floating a => MetaUnit u a
pi :: MetaUnit u a
$cexp :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
exp :: MetaUnit u a -> MetaUnit u a
$clog :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
log :: MetaUnit u a -> MetaUnit u a
$csqrt :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
sqrt :: MetaUnit u a -> MetaUnit u a
$c** :: forall (u :: Dim) a.
Floating a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
** :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$clogBase :: forall (u :: Dim) a.
Floating a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
logBase :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$csin :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
sin :: MetaUnit u a -> MetaUnit u a
$ccos :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
cos :: MetaUnit u a -> MetaUnit u a
$ctan :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
tan :: MetaUnit u a -> MetaUnit u a
$casin :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
asin :: MetaUnit u a -> MetaUnit u a
$cacos :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
acos :: MetaUnit u a -> MetaUnit u a
$catan :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
atan :: MetaUnit u a -> MetaUnit u a
$csinh :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
sinh :: MetaUnit u a -> MetaUnit u a
$ccosh :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
cosh :: MetaUnit u a -> MetaUnit u a
$ctanh :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
tanh :: MetaUnit u a -> MetaUnit u a
$casinh :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
asinh :: MetaUnit u a -> MetaUnit u a
$cacosh :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
acosh :: MetaUnit u a -> MetaUnit u a
$catanh :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
atanh :: MetaUnit u a -> MetaUnit u a
$clog1p :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
log1p :: MetaUnit u a -> MetaUnit u a
$cexpm1 :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
expm1 :: MetaUnit u a -> MetaUnit u a
$clog1pexp :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
log1pexp :: MetaUnit u a -> MetaUnit u a
$clog1mexp :: forall (u :: Dim) a. Floating a => MetaUnit u a -> MetaUnit u a
log1mexp :: MetaUnit u a -> MetaUnit u a
Floating, Num (MetaUnit u a)
Ord (MetaUnit u a)
(Num (MetaUnit u a), Ord (MetaUnit u a)) =>
(MetaUnit u a -> Rational) -> Real (MetaUnit u a)
MetaUnit u a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall (u :: Dim) a. Real a => Num (MetaUnit u a)
forall (u :: Dim) a. Real a => Ord (MetaUnit u a)
forall (u :: Dim) a. Real a => MetaUnit u a -> Rational
$ctoRational :: forall (u :: Dim) a. Real a => MetaUnit u a -> Rational
toRational :: MetaUnit u a -> Rational
Real
           , Fractional (MetaUnit u a)
Real (MetaUnit u a)
(Real (MetaUnit u a), Fractional (MetaUnit u a)) =>
(forall b. Integral b => MetaUnit u a -> (b, MetaUnit u a))
-> (forall b. Integral b => MetaUnit u a -> b)
-> (forall b. Integral b => MetaUnit u a -> b)
-> (forall b. Integral b => MetaUnit u a -> b)
-> (forall b. Integral b => MetaUnit u a -> b)
-> RealFrac (MetaUnit u a)
forall b. Integral b => MetaUnit u a -> b
forall b. Integral b => MetaUnit u a -> (b, MetaUnit u a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall (u :: Dim) a. RealFrac a => Fractional (MetaUnit u a)
forall (u :: Dim) a. RealFrac a => Real (MetaUnit u a)
forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> b
forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> (b, MetaUnit u a)
$cproperFraction :: forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> (b, MetaUnit u a)
properFraction :: forall b. Integral b => MetaUnit u a -> (b, MetaUnit u a)
$ctruncate :: forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> b
truncate :: forall b. Integral b => MetaUnit u a -> b
$cround :: forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> b
round :: forall b. Integral b => MetaUnit u a -> b
$cceiling :: forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> b
ceiling :: forall b. Integral b => MetaUnit u a -> b
$cfloor :: forall (u :: Dim) a b.
(RealFrac a, Integral b) =>
MetaUnit u a -> b
floor :: forall b. Integral b => MetaUnit u a -> b
RealFrac, Floating (MetaUnit u a)
RealFrac (MetaUnit u a)
(RealFrac (MetaUnit u a), Floating (MetaUnit u a)) =>
(MetaUnit u a -> Integer)
-> (MetaUnit u a -> Int)
-> (MetaUnit u a -> (Int, Int))
-> (MetaUnit u a -> (Integer, Int))
-> (Integer -> Int -> MetaUnit u a)
-> (MetaUnit u a -> Int)
-> (MetaUnit u a -> MetaUnit u a)
-> (Int -> MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> Bool)
-> (MetaUnit u a -> Bool)
-> (MetaUnit u a -> Bool)
-> (MetaUnit u a -> Bool)
-> (MetaUnit u a -> Bool)
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> RealFloat (MetaUnit u a)
Int -> MetaUnit u a -> MetaUnit u a
Integer -> Int -> MetaUnit u a
MetaUnit u a -> Bool
MetaUnit u a -> Int
MetaUnit u a -> Integer
MetaUnit u a -> (Int, Int)
MetaUnit u a -> (Integer, Int)
MetaUnit u a -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
forall (u :: Dim) a. RealFloat a => Floating (MetaUnit u a)
forall (u :: Dim) a. RealFloat a => RealFrac (MetaUnit u a)
forall (u :: Dim) a.
RealFloat a =>
Int -> MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a. RealFloat a => Integer -> Int -> MetaUnit u a
forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Bool
forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Int
forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Integer
forall (u :: Dim) a. RealFloat a => MetaUnit u a -> (Int, Int)
forall (u :: Dim) a. RealFloat a => MetaUnit u a -> (Integer, Int)
forall (u :: Dim) a. RealFloat a => MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a.
RealFloat a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$cfloatRadix :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Integer
floatRadix :: MetaUnit u a -> Integer
$cfloatDigits :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Int
floatDigits :: MetaUnit u a -> Int
$cfloatRange :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> (Int, Int)
floatRange :: MetaUnit u a -> (Int, Int)
$cdecodeFloat :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> (Integer, Int)
decodeFloat :: MetaUnit u a -> (Integer, Int)
$cencodeFloat :: forall (u :: Dim) a. RealFloat a => Integer -> Int -> MetaUnit u a
encodeFloat :: Integer -> Int -> MetaUnit u a
$cexponent :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Int
exponent :: MetaUnit u a -> Int
$csignificand :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> MetaUnit u a
significand :: MetaUnit u a -> MetaUnit u a
$cscaleFloat :: forall (u :: Dim) a.
RealFloat a =>
Int -> MetaUnit u a -> MetaUnit u a
scaleFloat :: Int -> MetaUnit u a -> MetaUnit u a
$cisNaN :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Bool
isNaN :: MetaUnit u a -> Bool
$cisInfinite :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Bool
isInfinite :: MetaUnit u a -> Bool
$cisDenormalized :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Bool
isDenormalized :: MetaUnit u a -> Bool
$cisNegativeZero :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Bool
isNegativeZero :: MetaUnit u a -> Bool
$cisIEEE :: forall (u :: Dim) a. RealFloat a => MetaUnit u a -> Bool
isIEEE :: MetaUnit u a -> Bool
$catan2 :: forall (u :: Dim) a.
RealFloat a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
atan2 :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
RealFloat, MetaUnit u a
MetaUnit u a -> MetaUnit u a -> Bounded (MetaUnit u a)
forall a. a -> a -> Bounded a
forall (u :: Dim) a. Bounded a => MetaUnit u a
$cminBound :: forall (u :: Dim) a. Bounded a => MetaUnit u a
minBound :: MetaUnit u a
$cmaxBound :: forall (u :: Dim) a. Bounded a => MetaUnit u a
maxBound :: MetaUnit u a
Bounded, Int -> MetaUnit u a
MetaUnit u a -> Int
MetaUnit u a -> [MetaUnit u a]
MetaUnit u a -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
MetaUnit u a -> MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
(MetaUnit u a -> MetaUnit u a)
-> (MetaUnit u a -> MetaUnit u a)
-> (Int -> MetaUnit u a)
-> (MetaUnit u a -> Int)
-> (MetaUnit u a -> [MetaUnit u a])
-> (MetaUnit u a -> MetaUnit u a -> [MetaUnit u a])
-> (MetaUnit u a -> MetaUnit u a -> [MetaUnit u a])
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a -> [MetaUnit u a])
-> Enum (MetaUnit u a)
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
forall (u :: Dim) a. Enum a => Int -> MetaUnit u a
forall (u :: Dim) a. Enum a => MetaUnit u a -> Int
forall (u :: Dim) a. Enum a => MetaUnit u a -> [MetaUnit u a]
forall (u :: Dim) a. Enum a => MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a.
Enum a =>
MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
forall (u :: Dim) a.
Enum a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
$csucc :: forall (u :: Dim) a. Enum a => MetaUnit u a -> MetaUnit u a
succ :: MetaUnit u a -> MetaUnit u a
$cpred :: forall (u :: Dim) a. Enum a => MetaUnit u a -> MetaUnit u a
pred :: MetaUnit u a -> MetaUnit u a
$ctoEnum :: forall (u :: Dim) a. Enum a => Int -> MetaUnit u a
toEnum :: Int -> MetaUnit u a
$cfromEnum :: forall (u :: Dim) a. Enum a => MetaUnit u a -> Int
fromEnum :: MetaUnit u a -> Int
$cenumFrom :: forall (u :: Dim) a. Enum a => MetaUnit u a -> [MetaUnit u a]
enumFrom :: MetaUnit u a -> [MetaUnit u a]
$cenumFromThen :: forall (u :: Dim) a.
Enum a =>
MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
enumFromThen :: MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
$cenumFromTo :: forall (u :: Dim) a.
Enum a =>
MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
enumFromTo :: MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
$cenumFromThenTo :: forall (u :: Dim) a.
Enum a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
enumFromThenTo :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a -> [MetaUnit u a]
Enum, NonEmpty (MetaUnit u a) -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
(MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> (NonEmpty (MetaUnit u a) -> MetaUnit u a)
-> (forall b. Integral b => b -> MetaUnit u a -> MetaUnit u a)
-> Semigroup (MetaUnit u a)
forall b. Integral b => b -> MetaUnit u a -> MetaUnit u a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall (u :: Dim) a.
Semigroup a =>
NonEmpty (MetaUnit u a) -> MetaUnit u a
forall (u :: Dim) a.
Semigroup a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
forall (u :: Dim) a b.
(Semigroup a, Integral b) =>
b -> MetaUnit u a -> MetaUnit u a
$c<> :: forall (u :: Dim) a.
Semigroup a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
<> :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$csconcat :: forall (u :: Dim) a.
Semigroup a =>
NonEmpty (MetaUnit u a) -> MetaUnit u a
sconcat :: NonEmpty (MetaUnit u a) -> MetaUnit u a
$cstimes :: forall (u :: Dim) a b.
(Semigroup a, Integral b) =>
b -> MetaUnit u a -> MetaUnit u a
stimes :: forall b. Integral b => b -> MetaUnit u a -> MetaUnit u a
Semigroup, Semigroup (MetaUnit u a)
MetaUnit u a
Semigroup (MetaUnit u a) =>
MetaUnit u a
-> (MetaUnit u a -> MetaUnit u a -> MetaUnit u a)
-> ([MetaUnit u a] -> MetaUnit u a)
-> Monoid (MetaUnit u a)
[MetaUnit u a] -> MetaUnit u a
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall (u :: Dim) a. Monoid a => Semigroup (MetaUnit u a)
forall (u :: Dim) a. Monoid a => MetaUnit u a
forall (u :: Dim) a. Monoid a => [MetaUnit u a] -> MetaUnit u a
forall (u :: Dim) a.
Monoid a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$cmempty :: forall (u :: Dim) a. Monoid a => MetaUnit u a
mempty :: MetaUnit u a
$cmappend :: forall (u :: Dim) a.
Monoid a =>
MetaUnit u a -> MetaUnit u a -> MetaUnit u a
mappend :: MetaUnit u a -> MetaUnit u a -> MetaUnit u a
$cmconcat :: forall (u :: Dim) a. Monoid a => [MetaUnit u a] -> MetaUnit u a
mconcat :: [MetaUnit u a] -> MetaUnit u a
Monoid, (forall a b. (a -> b) -> MetaUnit u a -> MetaUnit u b)
-> (forall a b. a -> MetaUnit u b -> MetaUnit u a)
-> Functor (MetaUnit u)
forall a b. a -> MetaUnit u b -> MetaUnit u a
forall a b. (a -> b) -> MetaUnit u a -> MetaUnit u b
forall (f :: Dim).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (u :: Dim) a b. a -> MetaUnit u b -> MetaUnit u a
forall (u :: Dim) a b. (a -> b) -> MetaUnit u a -> MetaUnit u b
$cfmap :: forall (u :: Dim) a b. (a -> b) -> MetaUnit u a -> MetaUnit u b
fmap :: forall a b. (a -> b) -> MetaUnit u a -> MetaUnit u b
$c<$ :: forall (u :: Dim) a b. a -> MetaUnit u b -> MetaUnit u a
<$ :: forall a b. a -> MetaUnit u b -> MetaUnit u a
Functor)

instance ShowUnit u => ShowUnit (MetaUnit u) where
  type ShowUnitType (MetaUnit u) = ShowUnitType u
  prettysUnitPrec :: Int -> ShowS
prettysUnitPrec = forall (u :: Dim). ShowUnit u => Int -> ShowS
prettysUnitPrec @u
  showsUnitPrec :: Int -> ShowS
showsUnitPrec = forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @u

instance (Show a, ShowUnit u) => Show (MetaUnit u a) where
  showsPrec :: Int -> MetaUnit u a -> ShowS
showsPrec = Int -> MetaUnit u a -> ShowS
forall (u :: Dim) a. (ShowUnit u, Show a) => Int -> u a -> ShowS
showsQuantityPrec

instance IsUnit u => IsUnit (MetaUnit u) where
  type DimOf (MetaUnit u) = DimOf u

--------------------------------------------------------------------------------


-- | A unit that has no dimension.

--

-- @

-- type MyHertz = NoUnit ./. Second

-- @

--

newtype NoUnit a = NoUnit a
  deriving ( Int -> NoUnit a -> ShowS
[NoUnit a] -> ShowS
NoUnit a -> String
(Int -> NoUnit a -> ShowS)
-> (NoUnit a -> String) -> ([NoUnit a] -> ShowS) -> Show (NoUnit a)
forall a. Show a => Int -> NoUnit a -> ShowS
forall a. Show a => [NoUnit a] -> ShowS
forall a. Show a => NoUnit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> NoUnit a -> ShowS
showsPrec :: Int -> NoUnit a -> ShowS
$cshow :: forall a. Show a => NoUnit a -> String
show :: NoUnit a -> String
$cshowList :: forall a. Show a => [NoUnit a] -> ShowS
showList :: [NoUnit a] -> ShowS
Show, NoUnit a -> NoUnit a -> Bool
(NoUnit a -> NoUnit a -> Bool)
-> (NoUnit a -> NoUnit a -> Bool) -> Eq (NoUnit a)
forall a. Eq a => NoUnit a -> NoUnit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => NoUnit a -> NoUnit a -> Bool
== :: NoUnit a -> NoUnit a -> Bool
$c/= :: forall a. Eq a => NoUnit a -> NoUnit a -> Bool
/= :: NoUnit a -> NoUnit a -> Bool
Eq, Eq (NoUnit a)
Eq (NoUnit a) =>
(NoUnit a -> NoUnit a -> Ordering)
-> (NoUnit a -> NoUnit a -> Bool)
-> (NoUnit a -> NoUnit a -> Bool)
-> (NoUnit a -> NoUnit a -> Bool)
-> (NoUnit a -> NoUnit a -> Bool)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> Ord (NoUnit a)
NoUnit a -> NoUnit a -> Bool
NoUnit a -> NoUnit a -> Ordering
NoUnit a -> NoUnit a -> NoUnit a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (NoUnit a)
forall a. Ord a => NoUnit a -> NoUnit a -> Bool
forall a. Ord a => NoUnit a -> NoUnit a -> Ordering
forall a. Ord a => NoUnit a -> NoUnit a -> NoUnit a
$ccompare :: forall a. Ord a => NoUnit a -> NoUnit a -> Ordering
compare :: NoUnit a -> NoUnit a -> Ordering
$c< :: forall a. Ord a => NoUnit a -> NoUnit a -> Bool
< :: NoUnit a -> NoUnit a -> Bool
$c<= :: forall a. Ord a => NoUnit a -> NoUnit a -> Bool
<= :: NoUnit a -> NoUnit a -> Bool
$c> :: forall a. Ord a => NoUnit a -> NoUnit a -> Bool
> :: NoUnit a -> NoUnit a -> Bool
$c>= :: forall a. Ord a => NoUnit a -> NoUnit a -> Bool
>= :: NoUnit a -> NoUnit a -> Bool
$cmax :: forall a. Ord a => NoUnit a -> NoUnit a -> NoUnit a
max :: NoUnit a -> NoUnit a -> NoUnit a
$cmin :: forall a. Ord a => NoUnit a -> NoUnit a -> NoUnit a
min :: NoUnit a -> NoUnit a -> NoUnit a
Ord, Integer -> NoUnit a
NoUnit a -> NoUnit a
NoUnit a -> NoUnit a -> NoUnit a
(NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (Integer -> NoUnit a)
-> Num (NoUnit a)
forall a. Num a => Integer -> NoUnit a
forall a. Num a => NoUnit a -> NoUnit a
forall a. Num a => NoUnit a -> NoUnit a -> NoUnit a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: forall a. Num a => NoUnit a -> NoUnit a -> NoUnit a
+ :: NoUnit a -> NoUnit a -> NoUnit a
$c- :: forall a. Num a => NoUnit a -> NoUnit a -> NoUnit a
- :: NoUnit a -> NoUnit a -> NoUnit a
$c* :: forall a. Num a => NoUnit a -> NoUnit a -> NoUnit a
* :: NoUnit a -> NoUnit a -> NoUnit a
$cnegate :: forall a. Num a => NoUnit a -> NoUnit a
negate :: NoUnit a -> NoUnit a
$cabs :: forall a. Num a => NoUnit a -> NoUnit a
abs :: NoUnit a -> NoUnit a
$csignum :: forall a. Num a => NoUnit a -> NoUnit a
signum :: NoUnit a -> NoUnit a
$cfromInteger :: forall a. Num a => Integer -> NoUnit a
fromInteger :: Integer -> NoUnit a
Num, Num (NoUnit a)
Num (NoUnit a) =>
(NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (Rational -> NoUnit a)
-> Fractional (NoUnit a)
Rational -> NoUnit a
NoUnit a -> NoUnit a
NoUnit a -> NoUnit a -> NoUnit a
forall a. Fractional a => Num (NoUnit a)
forall a. Fractional a => Rational -> NoUnit a
forall a. Fractional a => NoUnit a -> NoUnit a
forall a. Fractional a => NoUnit a -> NoUnit a -> NoUnit a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
$c/ :: forall a. Fractional a => NoUnit a -> NoUnit a -> NoUnit a
/ :: NoUnit a -> NoUnit a -> NoUnit a
$crecip :: forall a. Fractional a => NoUnit a -> NoUnit a
recip :: NoUnit a -> NoUnit a
$cfromRational :: forall a. Fractional a => Rational -> NoUnit a
fromRational :: Rational -> NoUnit a
Fractional, Fractional (NoUnit a)
NoUnit a
Fractional (NoUnit a) =>
NoUnit a
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> (NoUnit a -> NoUnit a)
-> Floating (NoUnit a)
NoUnit a -> NoUnit a
NoUnit a -> NoUnit a -> NoUnit a
forall a. Floating a => Fractional (NoUnit a)
forall a. Floating a => NoUnit a
forall a. Floating a => NoUnit a -> NoUnit a
forall a. Floating a => NoUnit a -> NoUnit a -> NoUnit a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
$cpi :: forall a. Floating a => NoUnit a
pi :: NoUnit a
$cexp :: forall a. Floating a => NoUnit a -> NoUnit a
exp :: NoUnit a -> NoUnit a
$clog :: forall a. Floating a => NoUnit a -> NoUnit a
log :: NoUnit a -> NoUnit a
$csqrt :: forall a. Floating a => NoUnit a -> NoUnit a
sqrt :: NoUnit a -> NoUnit a
$c** :: forall a. Floating a => NoUnit a -> NoUnit a -> NoUnit a
** :: NoUnit a -> NoUnit a -> NoUnit a
$clogBase :: forall a. Floating a => NoUnit a -> NoUnit a -> NoUnit a
logBase :: NoUnit a -> NoUnit a -> NoUnit a
$csin :: forall a. Floating a => NoUnit a -> NoUnit a
sin :: NoUnit a -> NoUnit a
$ccos :: forall a. Floating a => NoUnit a -> NoUnit a
cos :: NoUnit a -> NoUnit a
$ctan :: forall a. Floating a => NoUnit a -> NoUnit a
tan :: NoUnit a -> NoUnit a
$casin :: forall a. Floating a => NoUnit a -> NoUnit a
asin :: NoUnit a -> NoUnit a
$cacos :: forall a. Floating a => NoUnit a -> NoUnit a
acos :: NoUnit a -> NoUnit a
$catan :: forall a. Floating a => NoUnit a -> NoUnit a
atan :: NoUnit a -> NoUnit a
$csinh :: forall a. Floating a => NoUnit a -> NoUnit a
sinh :: NoUnit a -> NoUnit a
$ccosh :: forall a. Floating a => NoUnit a -> NoUnit a
cosh :: NoUnit a -> NoUnit a
$ctanh :: forall a. Floating a => NoUnit a -> NoUnit a
tanh :: NoUnit a -> NoUnit a
$casinh :: forall a. Floating a => NoUnit a -> NoUnit a
asinh :: NoUnit a -> NoUnit a
$cacosh :: forall a. Floating a => NoUnit a -> NoUnit a
acosh :: NoUnit a -> NoUnit a
$catanh :: forall a. Floating a => NoUnit a -> NoUnit a
atanh :: NoUnit a -> NoUnit a
$clog1p :: forall a. Floating a => NoUnit a -> NoUnit a
log1p :: NoUnit a -> NoUnit a
$cexpm1 :: forall a. Floating a => NoUnit a -> NoUnit a
expm1 :: NoUnit a -> NoUnit a
$clog1pexp :: forall a. Floating a => NoUnit a -> NoUnit a
log1pexp :: NoUnit a -> NoUnit a
$clog1mexp :: forall a. Floating a => NoUnit a -> NoUnit a
log1mexp :: NoUnit a -> NoUnit a
Floating, Num (NoUnit a)
Ord (NoUnit a)
(Num (NoUnit a), Ord (NoUnit a)) =>
(NoUnit a -> Rational) -> Real (NoUnit a)
NoUnit a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall a. Real a => Num (NoUnit a)
forall a. Real a => Ord (NoUnit a)
forall a. Real a => NoUnit a -> Rational
$ctoRational :: forall a. Real a => NoUnit a -> Rational
toRational :: NoUnit a -> Rational
Real
           , Fractional (NoUnit a)
Real (NoUnit a)
(Real (NoUnit a), Fractional (NoUnit a)) =>
(forall b. Integral b => NoUnit a -> (b, NoUnit a))
-> (forall b. Integral b => NoUnit a -> b)
-> (forall b. Integral b => NoUnit a -> b)
-> (forall b. Integral b => NoUnit a -> b)
-> (forall b. Integral b => NoUnit a -> b)
-> RealFrac (NoUnit a)
forall b. Integral b => NoUnit a -> b
forall b. Integral b => NoUnit a -> (b, NoUnit a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall a. RealFrac a => Fractional (NoUnit a)
forall a. RealFrac a => Real (NoUnit a)
forall a b. (RealFrac a, Integral b) => NoUnit a -> b
forall a b. (RealFrac a, Integral b) => NoUnit a -> (b, NoUnit a)
$cproperFraction :: forall a b. (RealFrac a, Integral b) => NoUnit a -> (b, NoUnit a)
properFraction :: forall b. Integral b => NoUnit a -> (b, NoUnit a)
$ctruncate :: forall a b. (RealFrac a, Integral b) => NoUnit a -> b
truncate :: forall b. Integral b => NoUnit a -> b
$cround :: forall a b. (RealFrac a, Integral b) => NoUnit a -> b
round :: forall b. Integral b => NoUnit a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => NoUnit a -> b
ceiling :: forall b. Integral b => NoUnit a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => NoUnit a -> b
floor :: forall b. Integral b => NoUnit a -> b
RealFrac, Floating (NoUnit a)
RealFrac (NoUnit a)
(RealFrac (NoUnit a), Floating (NoUnit a)) =>
(NoUnit a -> Integer)
-> (NoUnit a -> Int)
-> (NoUnit a -> (Int, Int))
-> (NoUnit a -> (Integer, Int))
-> (Integer -> Int -> NoUnit a)
-> (NoUnit a -> Int)
-> (NoUnit a -> NoUnit a)
-> (Int -> NoUnit a -> NoUnit a)
-> (NoUnit a -> Bool)
-> (NoUnit a -> Bool)
-> (NoUnit a -> Bool)
-> (NoUnit a -> Bool)
-> (NoUnit a -> Bool)
-> (NoUnit a -> NoUnit a -> NoUnit a)
-> RealFloat (NoUnit a)
Int -> NoUnit a -> NoUnit a
Integer -> Int -> NoUnit a
NoUnit a -> Bool
NoUnit a -> Int
NoUnit a -> Integer
NoUnit a -> (Int, Int)
NoUnit a -> (Integer, Int)
NoUnit a -> NoUnit a
NoUnit a -> NoUnit a -> NoUnit a
forall a. RealFloat a => Floating (NoUnit a)
forall a. RealFloat a => RealFrac (NoUnit a)
forall a. RealFloat a => Int -> NoUnit a -> NoUnit a
forall a. RealFloat a => Integer -> Int -> NoUnit a
forall a. RealFloat a => NoUnit a -> Bool
forall a. RealFloat a => NoUnit a -> Int
forall a. RealFloat a => NoUnit a -> Integer
forall a. RealFloat a => NoUnit a -> (Int, Int)
forall a. RealFloat a => NoUnit a -> (Integer, Int)
forall a. RealFloat a => NoUnit a -> NoUnit a
forall a. RealFloat a => NoUnit a -> NoUnit a -> NoUnit a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
$cfloatRadix :: forall a. RealFloat a => NoUnit a -> Integer
floatRadix :: NoUnit a -> Integer
$cfloatDigits :: forall a. RealFloat a => NoUnit a -> Int
floatDigits :: NoUnit a -> Int
$cfloatRange :: forall a. RealFloat a => NoUnit a -> (Int, Int)
floatRange :: NoUnit a -> (Int, Int)
$cdecodeFloat :: forall a. RealFloat a => NoUnit a -> (Integer, Int)
decodeFloat :: NoUnit a -> (Integer, Int)
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> NoUnit a
encodeFloat :: Integer -> Int -> NoUnit a
$cexponent :: forall a. RealFloat a => NoUnit a -> Int
exponent :: NoUnit a -> Int
$csignificand :: forall a. RealFloat a => NoUnit a -> NoUnit a
significand :: NoUnit a -> NoUnit a
$cscaleFloat :: forall a. RealFloat a => Int -> NoUnit a -> NoUnit a
scaleFloat :: Int -> NoUnit a -> NoUnit a
$cisNaN :: forall a. RealFloat a => NoUnit a -> Bool
isNaN :: NoUnit a -> Bool
$cisInfinite :: forall a. RealFloat a => NoUnit a -> Bool
isInfinite :: NoUnit a -> Bool
$cisDenormalized :: forall a. RealFloat a => NoUnit a -> Bool
isDenormalized :: NoUnit a -> Bool
$cisNegativeZero :: forall a. RealFloat a => NoUnit a -> Bool
isNegativeZero :: NoUnit a -> Bool
$cisIEEE :: forall a. RealFloat a => NoUnit a -> Bool
isIEEE :: NoUnit a -> Bool
$catan2 :: forall a. RealFloat a => NoUnit a -> NoUnit a -> NoUnit a
atan2 :: NoUnit a -> NoUnit a -> NoUnit a
RealFloat, (forall a b. (a -> b) -> NoUnit a -> NoUnit b)
-> (forall a b. a -> NoUnit b -> NoUnit a) -> Functor NoUnit
forall a b. a -> NoUnit b -> NoUnit a
forall a b. (a -> b) -> NoUnit a -> NoUnit b
forall (f :: Dim).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> NoUnit a -> NoUnit b
fmap :: forall a b. (a -> b) -> NoUnit a -> NoUnit b
$c<$ :: forall a b. a -> NoUnit b -> NoUnit a
<$ :: forall a b. a -> NoUnit b -> NoUnit a
Functor)

instance IsUnit NoUnit where
  type DimOf NoUnit = NoDim

instance IsDim NoDim where
  type DimToUnit NoDim = NoUnit


-- | Multiplication of two units.

--

-- @

-- type MyForceMoment = Newton .*. Meter

-- @

--

newtype ((u :: Unit) .*. (v :: Unit)) a = MulUnit a
  deriving ( (.*.) u v a -> (.*.) u v a -> Bool
((.*.) u v a -> (.*.) u v a -> Bool)
-> ((.*.) u v a -> (.*.) u v a -> Bool) -> Eq ((.*.) u v a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (u :: Dim) (v :: Dim) a.
Eq a =>
(.*.) u v a -> (.*.) u v a -> Bool
$c== :: forall (u :: Dim) (v :: Dim) a.
Eq a =>
(.*.) u v a -> (.*.) u v a -> Bool
== :: (.*.) u v a -> (.*.) u v a -> Bool
$c/= :: forall (u :: Dim) (v :: Dim) a.
Eq a =>
(.*.) u v a -> (.*.) u v a -> Bool
/= :: (.*.) u v a -> (.*.) u v a -> Bool
Eq, Eq ((.*.) u v a)
Eq ((.*.) u v a) =>
((.*.) u v a -> (.*.) u v a -> Ordering)
-> ((.*.) u v a -> (.*.) u v a -> Bool)
-> ((.*.) u v a -> (.*.) u v a -> Bool)
-> ((.*.) u v a -> (.*.) u v a -> Bool)
-> ((.*.) u v a -> (.*.) u v a -> Bool)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> Ord ((.*.) u v a)
(.*.) u v a -> (.*.) u v a -> Bool
(.*.) u v a -> (.*.) u v a -> Ordering
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (u :: Dim) (v :: Dim) a. Ord a => Eq ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Bool
forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Ordering
forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
$ccompare :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Ordering
compare :: (.*.) u v a -> (.*.) u v a -> Ordering
$c< :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Bool
< :: (.*.) u v a -> (.*.) u v a -> Bool
$c<= :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Bool
<= :: (.*.) u v a -> (.*.) u v a -> Bool
$c> :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Bool
> :: (.*.) u v a -> (.*.) u v a -> Bool
$c>= :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> Bool
>= :: (.*.) u v a -> (.*.) u v a -> Bool
$cmax :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
max :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$cmin :: forall (u :: Dim) (v :: Dim) a.
Ord a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
min :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
Ord, Integer -> (.*.) u v a
(.*.) u v a -> (.*.) u v a
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> (Integer -> (.*.) u v a)
-> Num ((.*.) u v a)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall (u :: Dim) (v :: Dim) a. Num a => Integer -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a. Num a => (.*.) u v a -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
Num a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
$c+ :: forall (u :: Dim) (v :: Dim) a.
Num a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
+ :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$c- :: forall (u :: Dim) (v :: Dim) a.
Num a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
- :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$c* :: forall (u :: Dim) (v :: Dim) a.
Num a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
* :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$cnegate :: forall (u :: Dim) (v :: Dim) a. Num a => (.*.) u v a -> (.*.) u v a
negate :: (.*.) u v a -> (.*.) u v a
$cabs :: forall (u :: Dim) (v :: Dim) a. Num a => (.*.) u v a -> (.*.) u v a
abs :: (.*.) u v a -> (.*.) u v a
$csignum :: forall (u :: Dim) (v :: Dim) a. Num a => (.*.) u v a -> (.*.) u v a
signum :: (.*.) u v a -> (.*.) u v a
$cfromInteger :: forall (u :: Dim) (v :: Dim) a. Num a => Integer -> (.*.) u v a
fromInteger :: Integer -> (.*.) u v a
Num, Num ((.*.) u v a)
Num ((.*.) u v a) =>
((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> (Rational -> (.*.) u v a)
-> Fractional ((.*.) u v a)
Rational -> (.*.) u v a
(.*.) u v a -> (.*.) u v a
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall (u :: Dim) (v :: Dim) a. Fractional a => Num ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a.
Fractional a =>
Rational -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
Fractional a =>
(.*.) u v a -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
Fractional a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
$c/ :: forall (u :: Dim) (v :: Dim) a.
Fractional a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
/ :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$crecip :: forall (u :: Dim) (v :: Dim) a.
Fractional a =>
(.*.) u v a -> (.*.) u v a
recip :: (.*.) u v a -> (.*.) u v a
$cfromRational :: forall (u :: Dim) (v :: Dim) a.
Fractional a =>
Rational -> (.*.) u v a
fromRational :: Rational -> (.*.) u v a
Fractional, Fractional ((.*.) u v a)
(.*.) u v a
Fractional ((.*.) u v a) =>
(.*.) u v a
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> (.*.) u v a)
-> Floating ((.*.) u v a)
(.*.) u v a -> (.*.) u v a
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
forall (u :: Dim) (v :: Dim) a.
Floating a =>
Fractional ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a. Floating a => (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
$cpi :: forall (u :: Dim) (v :: Dim) a. Floating a => (.*.) u v a
pi :: (.*.) u v a
$cexp :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
exp :: (.*.) u v a -> (.*.) u v a
$clog :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
log :: (.*.) u v a -> (.*.) u v a
$csqrt :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
sqrt :: (.*.) u v a -> (.*.) u v a
$c** :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
** :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$clogBase :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
logBase :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
$csin :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
sin :: (.*.) u v a -> (.*.) u v a
$ccos :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
cos :: (.*.) u v a -> (.*.) u v a
$ctan :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
tan :: (.*.) u v a -> (.*.) u v a
$casin :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
asin :: (.*.) u v a -> (.*.) u v a
$cacos :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
acos :: (.*.) u v a -> (.*.) u v a
$catan :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
atan :: (.*.) u v a -> (.*.) u v a
$csinh :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
sinh :: (.*.) u v a -> (.*.) u v a
$ccosh :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
cosh :: (.*.) u v a -> (.*.) u v a
$ctanh :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
tanh :: (.*.) u v a -> (.*.) u v a
$casinh :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
asinh :: (.*.) u v a -> (.*.) u v a
$cacosh :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
acosh :: (.*.) u v a -> (.*.) u v a
$catanh :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
atanh :: (.*.) u v a -> (.*.) u v a
$clog1p :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
log1p :: (.*.) u v a -> (.*.) u v a
$cexpm1 :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
expm1 :: (.*.) u v a -> (.*.) u v a
$clog1pexp :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
log1pexp :: (.*.) u v a -> (.*.) u v a
$clog1mexp :: forall (u :: Dim) (v :: Dim) a.
Floating a =>
(.*.) u v a -> (.*.) u v a
log1mexp :: (.*.) u v a -> (.*.) u v a
Floating, Num ((.*.) u v a)
Ord ((.*.) u v a)
(Num ((.*.) u v a), Ord ((.*.) u v a)) =>
((.*.) u v a -> Rational) -> Real ((.*.) u v a)
(.*.) u v a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall (u :: Dim) (v :: Dim) a. Real a => Num ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a. Real a => Ord ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a. Real a => (.*.) u v a -> Rational
$ctoRational :: forall (u :: Dim) (v :: Dim) a. Real a => (.*.) u v a -> Rational
toRational :: (.*.) u v a -> Rational
Real
           , Fractional ((.*.) u v a)
Real ((.*.) u v a)
(Real ((.*.) u v a), Fractional ((.*.) u v a)) =>
(forall b. Integral b => (.*.) u v a -> (b, (.*.) u v a))
-> (forall b. Integral b => (.*.) u v a -> b)
-> (forall b. Integral b => (.*.) u v a -> b)
-> (forall b. Integral b => (.*.) u v a -> b)
-> (forall b. Integral b => (.*.) u v a -> b)
-> RealFrac ((.*.) u v a)
forall b. Integral b => (.*.) u v a -> b
forall b. Integral b => (.*.) u v a -> (b, (.*.) u v a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall (u :: Dim) (v :: Dim) a.
RealFrac a =>
Fractional ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a. RealFrac a => Real ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> b
forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> (b, (.*.) u v a)
$cproperFraction :: forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> (b, (.*.) u v a)
properFraction :: forall b. Integral b => (.*.) u v a -> (b, (.*.) u v a)
$ctruncate :: forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> b
truncate :: forall b. Integral b => (.*.) u v a -> b
$cround :: forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> b
round :: forall b. Integral b => (.*.) u v a -> b
$cceiling :: forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> b
ceiling :: forall b. Integral b => (.*.) u v a -> b
$cfloor :: forall (u :: Dim) (v :: Dim) a b.
(RealFrac a, Integral b) =>
(.*.) u v a -> b
floor :: forall b. Integral b => (.*.) u v a -> b
RealFrac, Floating ((.*.) u v a)
RealFrac ((.*.) u v a)
(RealFrac ((.*.) u v a), Floating ((.*.) u v a)) =>
((.*.) u v a -> Integer)
-> ((.*.) u v a -> Int)
-> ((.*.) u v a -> (Int, Int))
-> ((.*.) u v a -> (Integer, Int))
-> (Integer -> Int -> (.*.) u v a)
-> ((.*.) u v a -> Int)
-> ((.*.) u v a -> (.*.) u v a)
-> (Int -> (.*.) u v a -> (.*.) u v a)
-> ((.*.) u v a -> Bool)
-> ((.*.) u v a -> Bool)
-> ((.*.) u v a -> Bool)
-> ((.*.) u v a -> Bool)
-> ((.*.) u v a -> Bool)
-> ((.*.) u v a -> (.*.) u v a -> (.*.) u v a)
-> RealFloat ((.*.) u v a)
Int -> (.*.) u v a -> (.*.) u v a
Integer -> Int -> (.*.) u v a
(.*.) u v a -> Bool
(.*.) u v a -> Int
(.*.) u v a -> Integer
(.*.) u v a -> (Int, Int)
(.*.) u v a -> (Integer, Int)
(.*.) u v a -> (.*.) u v a
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
Floating ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
RealFrac ((.*.) u v a)
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
Int -> (.*.) u v a -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
Integer -> Int -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Bool
forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Int
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> Integer
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (Int, Int)
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (Integer, Int)
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
$cfloatRadix :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> Integer
floatRadix :: (.*.) u v a -> Integer
$cfloatDigits :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Int
floatDigits :: (.*.) u v a -> Int
$cfloatRange :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (Int, Int)
floatRange :: (.*.) u v a -> (Int, Int)
$cdecodeFloat :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (Integer, Int)
decodeFloat :: (.*.) u v a -> (Integer, Int)
$cencodeFloat :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
Integer -> Int -> (.*.) u v a
encodeFloat :: Integer -> Int -> (.*.) u v a
$cexponent :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Int
exponent :: (.*.) u v a -> Int
$csignificand :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (.*.) u v a
significand :: (.*.) u v a -> (.*.) u v a
$cscaleFloat :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
Int -> (.*.) u v a -> (.*.) u v a
scaleFloat :: Int -> (.*.) u v a -> (.*.) u v a
$cisNaN :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Bool
isNaN :: (.*.) u v a -> Bool
$cisInfinite :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Bool
isInfinite :: (.*.) u v a -> Bool
$cisDenormalized :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Bool
isDenormalized :: (.*.) u v a -> Bool
$cisNegativeZero :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Bool
isNegativeZero :: (.*.) u v a -> Bool
$cisIEEE :: forall (u :: Dim) (v :: Dim) a. RealFloat a => (.*.) u v a -> Bool
isIEEE :: (.*.) u v a -> Bool
$catan2 :: forall (u :: Dim) (v :: Dim) a.
RealFloat a =>
(.*.) u v a -> (.*.) u v a -> (.*.) u v a
atan2 :: (.*.) u v a -> (.*.) u v a -> (.*.) u v a
RealFloat, (forall a b. (a -> b) -> (.*.) u v a -> (.*.) u v b)
-> (forall a b. a -> (.*.) u v b -> (.*.) u v a)
-> Functor (u .*. v)
forall a b. a -> (.*.) u v b -> (.*.) u v a
forall a b. (a -> b) -> (.*.) u v a -> (.*.) u v b
forall (f :: Dim).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (u :: Dim) (v :: Dim) a b. a -> (.*.) u v b -> (.*.) u v a
forall (u :: Dim) (v :: Dim) a b.
(a -> b) -> (.*.) u v a -> (.*.) u v b
$cfmap :: forall (u :: Dim) (v :: Dim) a b.
(a -> b) -> (.*.) u v a -> (.*.) u v b
fmap :: forall a b. (a -> b) -> (.*.) u v a -> (.*.) u v b
$c<$ :: forall (u :: Dim) (v :: Dim) a b. a -> (.*.) u v b -> (.*.) u v a
<$ :: forall a b. a -> (.*.) u v b -> (.*.) u v a
Functor)
  deriving Int -> (.*.) u v a -> ShowS
[(.*.) u v a] -> ShowS
(.*.) u v a -> String
(Int -> (.*.) u v a -> ShowS)
-> ((.*.) u v a -> String)
-> ([(.*.) u v a] -> ShowS)
-> Show ((.*.) u v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (u :: Dim) (v :: Dim) a.
(Show a, ShowUnit u, ShowUnit v) =>
Int -> (.*.) u v a -> ShowS
forall (u :: Dim) (v :: Dim) a.
(Show a, ShowUnit u, ShowUnit v) =>
[(.*.) u v a] -> ShowS
forall (u :: Dim) (v :: Dim) a.
(Show a, ShowUnit u, ShowUnit v) =>
(.*.) u v a -> String
$cshowsPrec :: forall (u :: Dim) (v :: Dim) a.
(Show a, ShowUnit u, ShowUnit v) =>
Int -> (.*.) u v a -> ShowS
showsPrec :: Int -> (.*.) u v a -> ShowS
$cshow :: forall (u :: Dim) (v :: Dim) a.
(Show a, ShowUnit u, ShowUnit v) =>
(.*.) u v a -> String
show :: (.*.) u v a -> String
$cshowList :: forall (u :: Dim) (v :: Dim) a.
(Show a, ShowUnit u, ShowUnit v) =>
[(.*.) u v a] -> ShowS
showList :: [(.*.) u v a] -> ShowS
Show via MetaUnit (u .*. v) a

infixr 7 .*.

instance (ShowUnit u, ShowUnit v) => ShowUnit (u .*. v) where
  type ShowUnitType (u .*. v) =
    ShowUnitType u
    :<>: Text "⋅" :<>: ShowUnitType v
  prettysUnitPrec :: Int -> ShowS
prettysUnitPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
7) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    forall (u :: Dim). ShowUnit u => Int -> ShowS
prettysUnitPrec @u Int
7 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"⋅" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  forall (u :: Dim). ShowUnit u => Int -> ShowS
prettysUnitPrec @v Int
7
  showsUnitPrec :: Int -> ShowS
showsUnitPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
7) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @u Int
7 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" .*. " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @v Int
7

instance (ShowDim u, ShowDim v) => ShowDim (u .*. v) where
  type ShowDimType (u .*. v) =
    ShowDimType u
    :<>: Text "⋅" :<>: ShowDimType v
  prettysDimPrec :: Int -> ShowS
prettysDimPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
7) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    forall (d :: Dim). ShowDim d => Int -> ShowS
prettysDimPrec @u Int
7 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"⋅" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  forall (d :: Dim). ShowDim d => Int -> ShowS
prettysDimPrec @v Int
7
  showsDimPrec :: Int -> ShowS
showsDimPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
7) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    forall (d :: Dim). ShowDim d => Int -> ShowS
showsDimPrec @u Int
7 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" .*. " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  forall (d :: Dim). ShowDim d => Int -> ShowS
showsDimPrec @v Int
7


instance (IsUnit u, IsUnit v) => IsUnit (u .*. v) where
  type DimOf (u .*. v) = DimOf' (u .*. v)

instance (IsDim d, IsDim e) => IsDim (d .*. e) where
  type DimToUnit (d .*. e) = DimToUnit d .*. DimToUnit e



-------------------------------- Unit division ---------------------------------


type family InverseUnit u where
  InverseUnit (u .*. v) = InverseUnit u .*. InverseUnit v
  InverseUnit (u .^. n) = NormalizeExp (u .^. Negate n)
  InverseUnit NoUnit = NoUnit
  InverseUnit u = u .^. Neg 1

-- | Division of two units.

--

-- @

-- type MySpeed a = (Meter ./. Second) a

-- type MyMolarEntropy a = (Joule ./. Mole .*. Kelvin) a

-- @

--

-- Notice that multiplication has priority over division.

--

type family (u :: Unit) ./. (v :: Unit) :: Unit where
  u ./. v = u .*. InverseUnit v

infix 6 ./.


----------------------------- Unit exponentiation ------------------------------



-- | Exponentiation of a unit

--

-- @

-- type Acceleration = Meter .*. Second .^. Neg 2

-- @

--

newtype ((u :: Unit) .^. (n :: ZZ)) a = PowUnit a
  deriving ( (.^.) u n a -> (.^.) u n a -> Bool
((.^.) u n a -> (.^.) u n a -> Bool)
-> ((.^.) u n a -> (.^.) u n a -> Bool) -> Eq ((.^.) u n a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (u :: Dim) (n :: ZZ) a.
Eq a =>
(.^.) u n a -> (.^.) u n a -> Bool
$c== :: forall (u :: Dim) (n :: ZZ) a.
Eq a =>
(.^.) u n a -> (.^.) u n a -> Bool
== :: (.^.) u n a -> (.^.) u n a -> Bool
$c/= :: forall (u :: Dim) (n :: ZZ) a.
Eq a =>
(.^.) u n a -> (.^.) u n a -> Bool
/= :: (.^.) u n a -> (.^.) u n a -> Bool
Eq, Eq ((.^.) u n a)
Eq ((.^.) u n a) =>
((.^.) u n a -> (.^.) u n a -> Ordering)
-> ((.^.) u n a -> (.^.) u n a -> Bool)
-> ((.^.) u n a -> (.^.) u n a -> Bool)
-> ((.^.) u n a -> (.^.) u n a -> Bool)
-> ((.^.) u n a -> (.^.) u n a -> Bool)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> Ord ((.^.) u n a)
(.^.) u n a -> (.^.) u n a -> Bool
(.^.) u n a -> (.^.) u n a -> Ordering
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (u :: Dim) (n :: ZZ) a. Ord a => Eq ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Bool
forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Ordering
forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
$ccompare :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Ordering
compare :: (.^.) u n a -> (.^.) u n a -> Ordering
$c< :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Bool
< :: (.^.) u n a -> (.^.) u n a -> Bool
$c<= :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Bool
<= :: (.^.) u n a -> (.^.) u n a -> Bool
$c> :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Bool
> :: (.^.) u n a -> (.^.) u n a -> Bool
$c>= :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> Bool
>= :: (.^.) u n a -> (.^.) u n a -> Bool
$cmax :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
max :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$cmin :: forall (u :: Dim) (n :: ZZ) a.
Ord a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
min :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
Ord, Integer -> (.^.) u n a
(.^.) u n a -> (.^.) u n a
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> (Integer -> (.^.) u n a)
-> Num ((.^.) u n a)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall (u :: Dim) (n :: ZZ) a. Num a => Integer -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a. Num a => (.^.) u n a -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
Num a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
$c+ :: forall (u :: Dim) (n :: ZZ) a.
Num a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
+ :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$c- :: forall (u :: Dim) (n :: ZZ) a.
Num a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
- :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$c* :: forall (u :: Dim) (n :: ZZ) a.
Num a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
* :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$cnegate :: forall (u :: Dim) (n :: ZZ) a. Num a => (.^.) u n a -> (.^.) u n a
negate :: (.^.) u n a -> (.^.) u n a
$cabs :: forall (u :: Dim) (n :: ZZ) a. Num a => (.^.) u n a -> (.^.) u n a
abs :: (.^.) u n a -> (.^.) u n a
$csignum :: forall (u :: Dim) (n :: ZZ) a. Num a => (.^.) u n a -> (.^.) u n a
signum :: (.^.) u n a -> (.^.) u n a
$cfromInteger :: forall (u :: Dim) (n :: ZZ) a. Num a => Integer -> (.^.) u n a
fromInteger :: Integer -> (.^.) u n a
Num, Num ((.^.) u n a)
Num ((.^.) u n a) =>
((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> (Rational -> (.^.) u n a)
-> Fractional ((.^.) u n a)
Rational -> (.^.) u n a
(.^.) u n a -> (.^.) u n a
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall (u :: Dim) (n :: ZZ) a. Fractional a => Num ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a.
Fractional a =>
Rational -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
Fractional a =>
(.^.) u n a -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
Fractional a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
$c/ :: forall (u :: Dim) (n :: ZZ) a.
Fractional a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
/ :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$crecip :: forall (u :: Dim) (n :: ZZ) a.
Fractional a =>
(.^.) u n a -> (.^.) u n a
recip :: (.^.) u n a -> (.^.) u n a
$cfromRational :: forall (u :: Dim) (n :: ZZ) a.
Fractional a =>
Rational -> (.^.) u n a
fromRational :: Rational -> (.^.) u n a
Fractional, Fractional ((.^.) u n a)
(.^.) u n a
Fractional ((.^.) u n a) =>
(.^.) u n a
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> (.^.) u n a)
-> Floating ((.^.) u n a)
(.^.) u n a -> (.^.) u n a
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
forall a.
Fractional a =>
a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
forall (u :: Dim) (n :: ZZ) a.
Floating a =>
Fractional ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a. Floating a => (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
$cpi :: forall (u :: Dim) (n :: ZZ) a. Floating a => (.^.) u n a
pi :: (.^.) u n a
$cexp :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
exp :: (.^.) u n a -> (.^.) u n a
$clog :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
log :: (.^.) u n a -> (.^.) u n a
$csqrt :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
sqrt :: (.^.) u n a -> (.^.) u n a
$c** :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
** :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$clogBase :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
logBase :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
$csin :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
sin :: (.^.) u n a -> (.^.) u n a
$ccos :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
cos :: (.^.) u n a -> (.^.) u n a
$ctan :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
tan :: (.^.) u n a -> (.^.) u n a
$casin :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
asin :: (.^.) u n a -> (.^.) u n a
$cacos :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
acos :: (.^.) u n a -> (.^.) u n a
$catan :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
atan :: (.^.) u n a -> (.^.) u n a
$csinh :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
sinh :: (.^.) u n a -> (.^.) u n a
$ccosh :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
cosh :: (.^.) u n a -> (.^.) u n a
$ctanh :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
tanh :: (.^.) u n a -> (.^.) u n a
$casinh :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
asinh :: (.^.) u n a -> (.^.) u n a
$cacosh :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
acosh :: (.^.) u n a -> (.^.) u n a
$catanh :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
atanh :: (.^.) u n a -> (.^.) u n a
$clog1p :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
log1p :: (.^.) u n a -> (.^.) u n a
$cexpm1 :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
expm1 :: (.^.) u n a -> (.^.) u n a
$clog1pexp :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
log1pexp :: (.^.) u n a -> (.^.) u n a
$clog1mexp :: forall (u :: Dim) (n :: ZZ) a.
Floating a =>
(.^.) u n a -> (.^.) u n a
log1mexp :: (.^.) u n a -> (.^.) u n a
Floating, Num ((.^.) u n a)
Ord ((.^.) u n a)
(Num ((.^.) u n a), Ord ((.^.) u n a)) =>
((.^.) u n a -> Rational) -> Real ((.^.) u n a)
(.^.) u n a -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall (u :: Dim) (n :: ZZ) a. Real a => Num ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a. Real a => Ord ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a. Real a => (.^.) u n a -> Rational
$ctoRational :: forall (u :: Dim) (n :: ZZ) a. Real a => (.^.) u n a -> Rational
toRational :: (.^.) u n a -> Rational
Real
           , Fractional ((.^.) u n a)
Real ((.^.) u n a)
(Real ((.^.) u n a), Fractional ((.^.) u n a)) =>
(forall b. Integral b => (.^.) u n a -> (b, (.^.) u n a))
-> (forall b. Integral b => (.^.) u n a -> b)
-> (forall b. Integral b => (.^.) u n a -> b)
-> (forall b. Integral b => (.^.) u n a -> b)
-> (forall b. Integral b => (.^.) u n a -> b)
-> RealFrac ((.^.) u n a)
forall b. Integral b => (.^.) u n a -> b
forall b. Integral b => (.^.) u n a -> (b, (.^.) u n a)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall (u :: Dim) (n :: ZZ) a.
RealFrac a =>
Fractional ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a. RealFrac a => Real ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> b
forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> (b, (.^.) u n a)
$cproperFraction :: forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> (b, (.^.) u n a)
properFraction :: forall b. Integral b => (.^.) u n a -> (b, (.^.) u n a)
$ctruncate :: forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> b
truncate :: forall b. Integral b => (.^.) u n a -> b
$cround :: forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> b
round :: forall b. Integral b => (.^.) u n a -> b
$cceiling :: forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> b
ceiling :: forall b. Integral b => (.^.) u n a -> b
$cfloor :: forall (u :: Dim) (n :: ZZ) a b.
(RealFrac a, Integral b) =>
(.^.) u n a -> b
floor :: forall b. Integral b => (.^.) u n a -> b
RealFrac, Floating ((.^.) u n a)
RealFrac ((.^.) u n a)
(RealFrac ((.^.) u n a), Floating ((.^.) u n a)) =>
((.^.) u n a -> Integer)
-> ((.^.) u n a -> Int)
-> ((.^.) u n a -> (Int, Int))
-> ((.^.) u n a -> (Integer, Int))
-> (Integer -> Int -> (.^.) u n a)
-> ((.^.) u n a -> Int)
-> ((.^.) u n a -> (.^.) u n a)
-> (Int -> (.^.) u n a -> (.^.) u n a)
-> ((.^.) u n a -> Bool)
-> ((.^.) u n a -> Bool)
-> ((.^.) u n a -> Bool)
-> ((.^.) u n a -> Bool)
-> ((.^.) u n a -> Bool)
-> ((.^.) u n a -> (.^.) u n a -> (.^.) u n a)
-> RealFloat ((.^.) u n a)
Int -> (.^.) u n a -> (.^.) u n a
Integer -> Int -> (.^.) u n a
(.^.) u n a -> Bool
(.^.) u n a -> Int
(.^.) u n a -> Integer
(.^.) u n a -> (Int, Int)
(.^.) u n a -> (Integer, Int)
(.^.) u n a -> (.^.) u n a
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
forall a.
(RealFrac a, Floating a) =>
(a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
Floating ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
RealFrac ((.^.) u n a)
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
Int -> (.^.) u n a -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
Integer -> Int -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Bool
forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Int
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> Integer
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (Int, Int)
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (Integer, Int)
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
$cfloatRadix :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> Integer
floatRadix :: (.^.) u n a -> Integer
$cfloatDigits :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Int
floatDigits :: (.^.) u n a -> Int
$cfloatRange :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (Int, Int)
floatRange :: (.^.) u n a -> (Int, Int)
$cdecodeFloat :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (Integer, Int)
decodeFloat :: (.^.) u n a -> (Integer, Int)
$cencodeFloat :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
Integer -> Int -> (.^.) u n a
encodeFloat :: Integer -> Int -> (.^.) u n a
$cexponent :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Int
exponent :: (.^.) u n a -> Int
$csignificand :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (.^.) u n a
significand :: (.^.) u n a -> (.^.) u n a
$cscaleFloat :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
Int -> (.^.) u n a -> (.^.) u n a
scaleFloat :: Int -> (.^.) u n a -> (.^.) u n a
$cisNaN :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Bool
isNaN :: (.^.) u n a -> Bool
$cisInfinite :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Bool
isInfinite :: (.^.) u n a -> Bool
$cisDenormalized :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Bool
isDenormalized :: (.^.) u n a -> Bool
$cisNegativeZero :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Bool
isNegativeZero :: (.^.) u n a -> Bool
$cisIEEE :: forall (u :: Dim) (n :: ZZ) a. RealFloat a => (.^.) u n a -> Bool
isIEEE :: (.^.) u n a -> Bool
$catan2 :: forall (u :: Dim) (n :: ZZ) a.
RealFloat a =>
(.^.) u n a -> (.^.) u n a -> (.^.) u n a
atan2 :: (.^.) u n a -> (.^.) u n a -> (.^.) u n a
RealFloat, (forall a b. (a -> b) -> (.^.) u n a -> (.^.) u n b)
-> (forall a b. a -> (.^.) u n b -> (.^.) u n a)
-> Functor (u .^. n)
forall a b. a -> (.^.) u n b -> (.^.) u n a
forall a b. (a -> b) -> (.^.) u n a -> (.^.) u n b
forall (f :: Dim).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (u :: Dim) (n :: ZZ) a b. a -> (.^.) u n b -> (.^.) u n a
forall (u :: Dim) (n :: ZZ) a b.
(a -> b) -> (.^.) u n a -> (.^.) u n b
$cfmap :: forall (u :: Dim) (n :: ZZ) a b.
(a -> b) -> (.^.) u n a -> (.^.) u n b
fmap :: forall a b. (a -> b) -> (.^.) u n a -> (.^.) u n b
$c<$ :: forall (u :: Dim) (n :: ZZ) a b. a -> (.^.) u n b -> (.^.) u n a
<$ :: forall a b. a -> (.^.) u n b -> (.^.) u n a
Functor)
  deriving Int -> (.^.) u n a -> ShowS
[(.^.) u n a] -> ShowS
(.^.) u n a -> String
(Int -> (.^.) u n a -> ShowS)
-> ((.^.) u n a -> String)
-> ([(.^.) u n a] -> ShowS)
-> Show ((.^.) u n a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (u :: Dim) (n :: ZZ) a.
(Show a, ShowUnit u, KnownInt n) =>
Int -> (.^.) u n a -> ShowS
forall (u :: Dim) (n :: ZZ) a.
(Show a, ShowUnit u, KnownInt n) =>
[(.^.) u n a] -> ShowS
forall (u :: Dim) (n :: ZZ) a.
(Show a, ShowUnit u, KnownInt n) =>
(.^.) u n a -> String
$cshowsPrec :: forall (u :: Dim) (n :: ZZ) a.
(Show a, ShowUnit u, KnownInt n) =>
Int -> (.^.) u n a -> ShowS
showsPrec :: Int -> (.^.) u n a -> ShowS
$cshow :: forall (u :: Dim) (n :: ZZ) a.
(Show a, ShowUnit u, KnownInt n) =>
(.^.) u n a -> String
show :: (.^.) u n a -> String
$cshowList :: forall (u :: Dim) (n :: ZZ) a.
(Show a, ShowUnit u, KnownInt n) =>
[(.^.) u n a] -> ShowS
showList :: [(.^.) u n a] -> ShowS
Show via MetaUnit (u .^. n) a
infix 8 .^.

-- | Positive exponentiation of a unit

--

-- @

-- type Area = Meter .^+ 2

-- @

--

type a .^+ b = a .^. Pos b
infix 8 .^+

-- | Negative exponentiation of a unit

--

-- @

-- type Hertz = Second .^- 1

-- @

--

type a .^- b = a .^. Neg b
infix 8 .^-

type instance DimId (d .^. n) = DimId d

type family ShowIntExponent (n :: ZZ) :: ErrorMessage where
  ShowIntExponent (Pos n) =
      If (n <=? 9) (ShowDigitExponent n) (Text "^" :<>: ShowType n)
  ShowIntExponent Zero = Text "⁰"
  ShowIntExponent (Neg n) =
      If (n <=? 9) (Text "⁻" :<>: ShowDigitExponent n)
                   (Text "^-" :<>: ShowType n)

type family ShowDigitExponent (n :: Nat) :: ErrorMessage where
  ShowDigitExponent 0 = Text "⁰"
  ShowDigitExponent 1 = Text "¹"
  ShowDigitExponent 2 = Text "²"
  ShowDigitExponent 3 = Text "³"
  ShowDigitExponent 4 = Text "⁴"
  ShowDigitExponent 5 = Text "⁵"
  ShowDigitExponent 6 = Text "⁶"
  ShowDigitExponent 7 = Text "⁷"
  ShowDigitExponent 8 = Text "⁸"
  ShowDigitExponent 9 = Text "⁹"

instance IsUnit u => IsUnit (u .^. n) where
  type DimOf (u .^. n) = DimOf' (u .^. n)

instance IsDim d  => IsDim (d .^. n) where
  type DimToUnit (d .^. n) = DimToUnit d .^. n


instance (ShowUnit u, KnownInt n) => ShowUnit (u .^. n) where
  type ShowUnitType (u .^. n) =
         ShowUnitType u :<>: ShowIntExponent n
  prettysUnitPrec :: Int -> ShowS
prettysUnitPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
8) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    forall (u :: Dim). ShowUnit u => Int -> ShowS
prettysUnitPrec @u Int
8 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  String -> ShowS
showString (Char -> Char
toSuperscript (Char -> Char) -> ShowS
forall (f :: Dim) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> String
forall a. Show a => a -> String
show (Proxy n -> Integer
forall (r :: ZZ) (proxy :: ZZ -> *).
KnownInt r =>
proxy r -> Integer
forall (proxy :: ZZ -> *). proxy n -> Integer
intVal (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n)))
  showsUnitPrec :: Int -> ShowS
showsUnitPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
8) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    if Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0 then
      forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @u Int
8 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
".^+" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ShowS
forall a. Show a => a -> ShowS
shows Integer
n
    else
      forall (u :: Dim). ShowUnit u => Int -> ShowS
showsUnitPrec @u Int
8 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
".^-" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ShowS
forall a. Show a => a -> ShowS
shows (-Integer
n)
    where
      n :: Integer
n = Proxy n -> Integer
forall (r :: ZZ) (proxy :: ZZ -> *).
KnownInt r =>
proxy r -> Integer
forall (proxy :: ZZ -> *). proxy n -> Integer
intVal (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n)

instance (ShowDim u, KnownInt n) => ShowDim (u .^. n) where
  type ShowDimType (u .^. n) =
         ShowDimType u :<>: ShowIntExponent n
  prettysDimPrec :: Int -> ShowS
prettysDimPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
8) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    forall (d :: Dim). ShowDim d => Int -> ShowS
prettysDimPrec @u Int
8 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  String -> ShowS
showString (Char -> Char
toSuperscript (Char -> Char) -> ShowS
forall (f :: Dim) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> String
forall a. Show a => a -> String
show (Proxy n -> Integer
forall (r :: ZZ) (proxy :: ZZ -> *).
KnownInt r =>
proxy r -> Integer
forall (proxy :: ZZ -> *). proxy n -> Integer
intVal (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n)))
  showsDimPrec :: Int -> ShowS
showsDimPrec Int
d = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
8) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    if Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0 then
      forall (d :: Dim). ShowDim d => Int -> ShowS
showsDimPrec @u Int
8 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
".^+" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ShowS
forall a. Show a => a -> ShowS
shows Integer
n
    else
      forall (d :: Dim). ShowDim d => Int -> ShowS
showsDimPrec @u Int
8 ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
".^-" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ShowS
forall a. Show a => a -> ShowS
shows (-Integer
n)
    where
      n :: Integer
n = Proxy n -> Integer
forall (r :: ZZ) (proxy :: ZZ -> *).
KnownInt r =>
proxy r -> Integer
forall (proxy :: ZZ -> *). proxy n -> Integer
intVal (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n)


toSuperscript :: Char -> Char
toSuperscript :: Char -> Char
toSuperscript Char
'0' = Char
'⁰'
toSuperscript Char
'1' = Char
'¹'
toSuperscript Char
'2' = Char
'²'
toSuperscript Char
'3' = Char
'³'
toSuperscript Char
'4' = Char
'⁴'
toSuperscript Char
'5' = Char
'⁵'
toSuperscript Char
'6' = Char
'⁶'
toSuperscript Char
'7' = Char
'⁷'
toSuperscript Char
'8' = Char
'⁸'
toSuperscript Char
'9' = Char
'⁹'
toSuperscript Char
'+' = Char
'⁺'
toSuperscript Char
'-' = Char
'⁻'
toSuperscript Char
')' = Char
'⁾'
toSuperscript Char
'(' = Char
'⁽'
toSuperscript Char
'=' = Char
'⁼'
toSuperscript Char
a = Char
a

------------------------------ Unit normalization ------------------------------


-- | Normalizes a unit by converting it to a product of  exponentiations of base

-- units.

type BaseUnitOf u = DimToUnit (DimOf u)

-- | Multiplies two units and normalizes the result.

--

type (u :: Unit) ~*~ (v :: Unit) = BaseUnitOf (u .*. v)

infixr 7 ~*~

-- | Divides two units and normalizes the result.

--

type (u :: Unit) ~/~ (v :: Unit) = BaseUnitOf (u ./. v)

infixr 6 ~/~

-- | Exponentiates a unit and normalizes the result.

--

type (u :: Unit) ~^~ (n :: ZZ) = BaseUnitOf (u .^. n)

infixr 8 ~^~


type family MulNoUnit d e where
  MulNoUnit NoUnit e = e
  MulNoUnit d NoUnit = d
  MulNoUnit d e = d .*. e

type family NormalizeExp u where
  NormalizeExp (u .^. Pos 1) = u
  NormalizeExp (u .^. Zero) = NoUnit
  NormalizeExp u = u


--------------------- Unit normalization left priority ----------------------


-- | Tries to normalize a unit without converting to base units.

--

-- >>> :kind! NormalizeUnitR (Minute .*. Second)

-- Minute .^. Pos 2

--

type NormalizeUnitL u = NormalizeFlatUnitL (Flatten u)

-- | Multiplies two units and use left weak normalization.

type (u :: Unit) .*~ (v :: Unit) = NormalizeUnitL (u .*. v)

infixr 7 .*~

-- | Divides two units and use left weak normalization.

type (u :: Unit) ./~ (v :: Unit) = NormalizeUnitL (u ./. v)

infixr 6 ./~

-- | Exponentiates a unit and use left weak normalization.

type (u :: Unit) .^~ (n :: ZZ) = NormalizeUnitL (u .^. n)

infixr 8 .^~


type family NormalizeFlatUnitL u where
  NormalizeFlatUnitL (u .*. NoUnit) = NormalizeFlatUnitL u
  NormalizeFlatUnitL (NoUnit .*. v) = NormalizeFlatUnitL v
  NormalizeFlatUnitL ((u .*. v) .*. w) = NormalizeFlatUnitL (u .*. (v .*. w))
  NormalizeFlatUnitL (u .*. v) =
    InsertUnitL (NormalizeFlatUnitL u) (NormalizeFlatUnitL v)
  NormalizeFlatUnitL (NoUnit .^. n) = NoUnit
  NormalizeFlatUnitL (u .^. n) = NormalizeExp (u .^. n)
  NormalizeFlatUnitL u = u

type family InsertUnitL u v where
  InsertUnitL NoUnit v = v
  InsertUnitL u NoUnit = u
  InsertUnitL (u .*. v) w =
    TypeError (Text
      "Insert unit : Removing left association failed in NormalizeFlatUnitL")
  InsertUnitL (u .^. n) (v .^. m .*. w) =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) (u .^. n) (v .^. m .*. w)
  InsertUnitL (u .^. n) (v .*. w) =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) (u .^. n) (v .*. w)
  InsertUnitL (u .^. n) (v .^. m) =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) (u .^. n) (v .^. m)
  InsertUnitL (u .^. n) v =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) (u .^. n) v
  InsertUnitL u (v .^. m .*. w) =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) u (v .^. m .*. w)
  InsertUnitL u (v .*. w) =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) u (v .*. w)
  InsertUnitL u (v .^. m) =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) u (v .^. m)
  InsertUnitL u v =
      InsertCmpL (CmpDim (DimOf u) (DimOf v)) u v

type family InsertCmpL cmp u v where
  InsertCmpL 'LT u (v .*. w) = u .*. v .*. w
  InsertCmpL 'GT u (v .*. w) = v .*. InsertUnitL u w
  InsertCmpL 'EQ u (v .*. w) = MulNoUnit (MulSameDimL u v) w
  InsertCmpL 'LT u v = u .*. v
  InsertCmpL 'GT u v = v .*. u
  InsertCmpL 'EQ u v = MulSameDimL u v

type family MulSameDimL u v where
  MulSameDimL (u .^. n) (v .^. m) = NormalizeExp (u .^. Add n m)
  MulSameDimL u (v .^. m) = NormalizeExp (u .^. Add (Pos 1) m)
  MulSameDimL (u .^. n) v = NormalizeExp (u .^. Add n (Pos 1))
  MulSameDimL u v = u .^. Pos 2



---------------------- Unit normalization right priotiy -----------------------


-- The only difference with right is MulSameDim



-- | Tries to normalize a unit without converting to base units. When two units

-- have the same dimension, they will be collapsed to an exponentiation right

-- most unit.

--

-- >>> :kind! NormalizeUnitR (Minute .*. Second)

-- Second .^. Pos 2

--

type NormalizeUnitR u = NormalizeFlatUnitR (Flatten u)

-- | Same as @'(~*.)'@ but with priority to right most units

type (u :: Unit) ~*. (v :: Unit) = NormalizeUnitR (u .*. v)

infixr 7 ~*.

-- | Same as @'(~/.)'@ but with priority to right most units

type (u :: Unit) ~/. (v :: Unit) = NormalizeUnitR (u ./. v)

infixr 7 ~/.

-- | Same as @'(.^~)'@ but with priority to right most units

type (u :: Unit) ~^. (n :: ZZ) = NormalizeUnitR (u .^. n)

infix 8  ~^.


type family NormalizeFlatUnitR u where
  NormalizeFlatUnitR (u .*. NoUnit) = NormalizeFlatUnitR u
  NormalizeFlatUnitR (NoUnit .*. v) = NormalizeFlatUnitR v
  NormalizeFlatUnitR ((u .*. v) .*. w) = NormalizeFlatUnitR (u .*. (v .*. w))
  NormalizeFlatUnitR (u .*. v) =
    InsertUnitR (NormalizeFlatUnitR u) (NormalizeFlatUnitR v)
  NormalizeFlatUnitR (NoUnit .^. n) = NoUnit
  NormalizeFlatUnitR (u .^. n) = NormalizeExp (u .^. n)
  NormalizeFlatUnitR u = u

type family InsertUnitR u v where
  InsertUnitR NoUnit v = v
  InsertUnitR u NoUnit = u
  InsertUnitR (u .*. v) w =
    TypeError (Text
      "Insert unit : Removing left association failed in NormalizeFlatUnitR")
  InsertUnitR (u .^. n) (v .^. m .*. w) =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) (u .^. n) (v .^. m .*. w)
  InsertUnitR (u .^. n) (v .*. w) =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) (u .^. n) (v .*. w)
  InsertUnitR (u .^. n) (v .^. m) =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) (u .^. n) (v .^. m)
  InsertUnitR (u .^. n) v =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) (u .^. n) v
  InsertUnitR u (v .^. m .*. w) =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) u (v .^. m .*. w)
  InsertUnitR u (v .*. w) =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) u (v .*. w)
  InsertUnitR u (v .^. m) =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) u (v .^. m)
  InsertUnitR u v =
      InsertCmpR (CmpDim (DimOf u) (DimOf v)) u v

type family InsertCmpR cmp u v where
  InsertCmpR 'LT u (v .*. w) = u .*. v .*. w
  InsertCmpR 'GT u (v .*. w) = v .*. InsertUnitR u w
  InsertCmpR 'EQ u (v .*. w) = MulNoUnit (MulSameDimR u v) w
  InsertCmpR 'LT u v = u .*. v
  InsertCmpR 'GT u v = v .*. u
  InsertCmpR 'EQ u v = MulSameDimR u v

type family MulSameDimR u v where
  MulSameDimR (u .^. n) (v .^. m) = NormalizeExp (v .^. Add n m)
  MulSameDimR u (v .^. m) = NormalizeExp (v .^. Add (Pos 1) m)
  MulSameDimR (u .^. n) v = NormalizeExp (v .^. Add n (Pos 1))
  MulSameDimR u v = v .^. Pos 2