hashirama/metabrush
1
0
Fork 0
mirror of https://gitlab.com/sheaf/metabrush.git synced 2024-11-05 14:53:37 +00:00
Code Issues Actions Projects Releases Wiki Activity

WIP: SIMD experiments

Browse source
This commit is contained in:
sheaf 2024-08-01 21:36:44 +02:00
parent e64ce375d2
commit 5f98165276
28 changed files with 1252 additions and 854 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
brush-strokes/brush-strokes.cabal
View file

@ -12,10 +12,15 @@ description:
extra-source-files: extra-source-files:
cbits/**/*.{cpp, hpp} cbits/**/*.{cpp, hpp}
flag use-simd
description: Use SIMD instructions to implement interval arithmetic.
default: True
manual: True
flag use-fma flag use-fma
description: Use fused-muliply add instructions to implement interval arithmetic. description: Use fused-muliply add instructions to implement interval arithmetic.
default: True default: False
manual: False manual: True
flag asserts flag asserts
description: Enable debugging assertions. description: Enable debugging assertions.
@ -97,6 +102,18 @@ common common
base base
>= 4.19 >= 4.19
if flag(use-simd)
cpp-options:
-DUSE_SIMD
ghc-options:
-mavx2
build-depends:
base
>= 4.20
-- 4.21
, ghc-prim
>= 0.11
if flag(asserts) if flag(asserts)
cpp-options: cpp-options:
-DASSERTS -DASSERTS
@ -160,9 +177,17 @@ library
, Math.Module.Internal , Math.Module.Internal
, TH.Utils , TH.Utils
if flag(use-fma) if flag(use-simd)
other-modules: other-modules:
Math.Interval.FMA Math.Interval.Internal.SIMD
if flag(use-fma) && !flag(use-simd)
other-modules:
Math.Interval.Internal.FMA
if !flag(use-fma) && !flag(use-simd)
other-modules:
Math.Interval.Internal.RoundedHW
build-depends: build-depends:
template-haskell template-haskell

15
brush-strokes/cabal.project
View file

@ -22,3 +22,18 @@ source-repository-package
type: git type: git
location: https://github.com/sheaf/eigen location: https://github.com/sheaf/eigen
tag: 3bc1d4bc53edb75e2ee3893763361aa0d5c7714a tag: 3bc1d4bc53edb75e2ee3893763361aa0d5c7714a
--------------
-- GHC HEAD --
--------------
repository head.hackage.ghc.haskell.org
url: https://ghc.gitlab.haskell.org/head.hackage/
secure: True
key-threshold: 3
root-keys:
7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d
26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329
f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89
active-repositories: hackage.haskell.org, head.hackage.ghc.haskell.org:override

2
brush-strokes/src/cusps/bench/Bench/Cases.hs
View file

@ -69,7 +69,7 @@ trickyCusp2BrushStroke =
defaultStartBoxes :: [ Int ] -> [ ( Int, [ Box 2 ] ) ] defaultStartBoxes :: [ Int ] -> [ ( Int, [ Box 2 ] ) ]
defaultStartBoxes is = defaultStartBoxes is =
[ ( i, [ 𝕀 ( ℝ2 zero zero ) ( ℝ2 one one ) ] ) | i <- is ] [ ( i, [ 𝕀ℝ2 ( 𝕀 zero one ) ( 𝕀 zero one ) ] ) | i <- is ]
zero, one :: Double zero, one :: Double
zero = 1e-6 zero = 1e-6

45
brush-strokes/src/cusps/bench/Bench/Types.hs
View file

@ -43,7 +43,7 @@ import Math.Root.Isolation
data BrushStroke = data BrushStroke =
forall nbParams. ParamsCt nbParams => forall nbParams. ParamsCt nbParams =>
BrushStroke BrushStroke
{ brush :: !( Brush ( ℝ nbParams ) ) { brush :: !( Brush nbParams )
, stroke :: !( Point nbParams, Curve Open () ( Point nbParams ) ) , stroke :: !( Point nbParams, Curve Open () ( Point nbParams ) )
} }
@ -60,18 +60,19 @@ data TestCase =
type ParamsCt nbParams type ParamsCt nbParams
= ( Show ( ℝ nbParams ) = ( Show ( ℝ nbParams )
, HasChainRule Double 2 ( ℝ nbParams ) , HasChainRule Double 2 ( ℝ nbParams )
, HasChainRule ( 𝕀 Double ) 3 ( 𝕀 ( ℝ nbParams ) ) , HasChainRule 𝕀 3 ( 𝕀ℝ nbParams )
, Applicative ( D 2 ( ℝ nbParams ) ) , Applicative ( D 2 ( ℝ nbParams ) )
, Applicative ( D 3 ( ℝ nbParams ) ) , Applicative ( D 3 ( ℝ nbParams ) )
, Traversable ( D 2 ( ℝ nbParams ) ) , Traversable ( D 2 ( ℝ nbParams ) )
, Traversable ( D 3 ( ℝ nbParams ) ) , Traversable ( D 3 ( ℝ nbParams ) )
, Representable Double ( ℝ nbParams ) , Representable Double ( ℝ nbParams )
, Representable 𝕀 ( 𝕀ℝ nbParams )
, Module Double ( T ( ℝ nbParams ) ) , Module Double ( T ( ℝ nbParams ) )
, Module ( 𝕀 Double ) ( T ( 𝕀 ( ℝ nbParams ) ) ) , Module 𝕀 ( T ( 𝕀ℝ nbParams ) )
, Module ( D 2 ( ℝ nbParams ) Double ) ( D 2 ( ℝ nbParams ) ( ℝ 2 ) ) , Module ( D 2 ( ℝ nbParams ) Double ) ( D 2 ( ℝ nbParams ) ( ℝ 2 ) )
, Module ( D 3 ( ℝ nbParams ) ( 𝕀 Double ) ) ( D 3 ( ℝ nbParams ) ( 𝕀 ( ℝ 2 ) ) ) , Module ( D 3 ( ℝ nbParams ) 𝕀 ) ( D 3 ( ℝ nbParams ) ( 𝕀ℝ 2 ) )
, Transcendental ( D 2 ( ℝ nbParams ) Double ) , Transcendental ( D 2 ( ℝ nbParams ) Double )
, Transcendental ( D 3 ( ℝ nbParams ) ( 𝕀 Double ) ) , Transcendental ( D 3 ( ℝ nbParams ) 𝕀 )
) )
newtype Params nbParams = Params { getParams :: ( ℝ nbParams ) } newtype Params nbParams = Params { getParams :: ( ℝ nbParams ) }
@ -87,70 +88,70 @@ deriving stock instance Show ( ℝ nbParams ) => Show ( Point nbParams )
getStrokeFunctions getStrokeFunctions
:: forall nbParams :: forall nbParams
. ParamsCt nbParams . ParamsCt nbParams
=> Brush ( ℝ nbParams ) => Brush nbParams
-- ^ brush shape -- ^ brush shape
-> Point nbParams -> Point nbParams
-- ^ start point -- ^ start point
-> Curve Open () ( Point nbParams ) -> Curve Open () ( Point nbParams )
-- ^ curve points -- ^ curve points
-> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
, 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) ) , 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
getStrokeFunctions ( Brush brushShape brushShapeI mbRot ) sp0 crv = getStrokeFunctions ( Brush brushShape brushShapeI mbRot ) sp0 crv =
let let
usedParams :: C 2 ( ℝ 1 ) ( ℝ nbParams ) usedParams :: C 2 ( ℝ 1 ) ( ℝ nbParams )
path :: C 2 ( ℝ 1 ) ( ℝ 2 ) path :: C 2 ( ℝ 1 ) ( ℝ 2 )
( path, usedParams ) = ( path, usedParams ) =
pathAndUsedParams @2 @() coerce id ( getParams . pointParams ) pathAndUsedParams @2 @ℝ coerce id id ( getParams . pointParams )
sp0 crv sp0 crv
usedParamsI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ nbParams ) usedParamsI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ nbParams )
pathI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) pathI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 )
( pathI, usedParamsI ) = ( pathI, usedParamsI ) =
pathAndUsedParams @3 @𝕀 coerce singleton ( getParams . pointParams ) pathAndUsedParams @3 @𝕀 coerce point point ( getParams . pointParams )
sp0 crv sp0 crv
in ( brushStrokeData @2 @( ℝ nbParams ) coerce coerce in ( brushStrokeData @2 @nbParams coerce coerce
path usedParams path usedParams
brushShape brushShape
mbRot mbRot
, brushStrokeData @3 @( ℝ nbParams ) coerce coerce , brushStrokeData @3 @nbParams coerce coerce
pathI usedParamsI pathI usedParamsI
brushShapeI brushShapeI
( fmap nonDecreasing mbRot ) ( fmap ( \ rot -> un𝕀ℝ1 . nonDecreasing ( ℝ1 . rot ) ) mbRot )
) )
{-# INLINEABLE getStrokeFunctions #-} {-# INLINEABLE getStrokeFunctions #-}
{-# SPECIALISE getStrokeFunctions {-# SPECIALISE getStrokeFunctions
:: Brush ( ℝ 1 ) :: Brush 1
-> Point 1 -> Point 1
-> Curve Open () ( Point 1 ) -> Curve Open () ( Point 1 )
-> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
, 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) ) , 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
{-# SPECIALISE getStrokeFunctions {-# SPECIALISE getStrokeFunctions
:: Brush ( ℝ 2 ) :: Brush 2
-> Point 2 -> Point 2
-> Curve Open () ( Point 2 ) -> Curve Open () ( Point 2 )
-> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
, 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) ) , 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
{-# SPECIALISE getStrokeFunctions {-# SPECIALISE getStrokeFunctions
:: Brush ( ℝ 3 ) :: Brush 3
-> Point 3 -> Point 3
-> Curve Open () ( Point 3 ) -> Curve Open () ( Point 3 )
-> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
, 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) ) , 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
{-# SPECIALISE getStrokeFunctions {-# SPECIALISE getStrokeFunctions
:: Brush ( ℝ 4 ) :: Brush 4
-> Point 4 -> Point 4
-> Curve Open () ( Point 4 ) -> Curve Open () ( Point 4 )
-> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
, 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) ) , 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
brushStrokeFunctions brushStrokeFunctions
:: BrushStroke :: BrushStroke
-> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
, 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) ) , 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
brushStrokeFunctions ( BrushStroke { stroke = ( sp0, crv ), brush = brush :: Brush ( ℝ nbParams ) } ) brushStrokeFunctions ( BrushStroke { stroke = ( sp0, crv ), brush = brush :: Brush nbParams } )
-- Trick for triggering specialisation... TODO improve this. -- Trick for triggering specialisation... TODO improve this.
| Just Refl <- sameNat @nbParams @1 Proxy Proxy | Just Refl <- sameNat @nbParams @1 Proxy Proxy
= getStrokeFunctions @1 brush sp0 crv = getStrokeFunctions @1 brush sp0 crv

18
brush-strokes/src/cusps/bench/Main.hs
View file

@ -167,10 +167,8 @@ instance Semigroup BigBoxes where
= j1 = j1
| otherwise | otherwise
= j2 = j2
widthX ( 𝕀 ( ℝ2 x_lo _y_lo ) ( ℝ2 x_hi _y_hi ) ) widthX ( 𝕀ℝ2 x _y ) = width x
= x_hi - x_lo widthY ( 𝕀ℝ2 _x y ) = width y
widthY ( 𝕀 ( ℝ2 _x_lo y_lo ) ( ℝ2 _x_hi y_hi ) )
= y_hi - y_lo
instance Monoid BigBoxes where instance Monoid BigBoxes where
mempty = BigBoxes Nothing Nothing Nothing mempty = BigBoxes Nothing Nothing Nothing
@ -206,8 +204,8 @@ benchGroups =
( defaultStartBoxes [ 0 .. 3 ] ) ( defaultStartBoxes [ 0 .. 3 ] )
| let ε_bis = 5e-3 -- <- [ 1e-6, 5e-6, 1e-5, 5e-5, 1e-4, 5e-4, 1e-4, 5e-4, 1e-3, 5e-3, 1e-2, 5e-2, 0.1, 0.2, 0.3 ] | let ε_bis = 5e-3 -- <- [ 1e-6, 5e-6, 1e-5, 5e-5, 1e-4, 5e-4, 1e-4, 5e-4, 1e-3, 5e-3, 1e-2, 5e-2, 0.1, 0.2, 0.3 ]
, (newtMeth, newtOpts) , (newtMeth, newtOpts)
<- [ ( "LP", \ hist -> NewtonLP ) <- [ --( "LP", \ hist -> NewtonLP )
, ( "GS_Complete", defaultNewtonOptions @2 @3 ) ( "GS_Complete", defaultNewtonOptions @2 @3 )
, ( "GS_Partial", \hist -> NewtonGaussSeidel $ ( defaultGaussSeidelOptions @2 @3 hist ) { gsUpdate = GS_Partial } ) , ( "GS_Partial", \hist -> NewtonGaussSeidel $ ( defaultGaussSeidelOptions @2 @3 hist ) { gsUpdate = GS_Partial } )
] ]
, let opts = , let opts =
@ -230,15 +228,15 @@ benchGroups =
getR1 (ℝ1 u) = u getR1 (ℝ1 u) = u
eval eval
:: ( I i ( ℝ 1 ) -> Seq ( I i ( ℝ 1 ) -> StrokeDatum k i ) ) :: ( I i 1 -> Seq ( I i 1 -> StrokeDatum k i ) )
-> ( I i ( ℝ 1 ), Int, I i ( ℝ 1 ) ) -> ( I i 1, Int, I i 1 )
-> StrokeDatum k i -> StrokeDatum k i
eval f ( t, i, s ) = ( f t `Seq.index` i ) s eval f ( t, i, s ) = ( f t `Seq.index` i ) s
mkVal :: Double -> Int -> Double -> ( ℝ 1, Int, ℝ 1 ) mkVal :: Double -> Int -> Double -> ( ℝ 1, Int, ℝ 1 )
mkVal t i s = ( ℝ1 t, i, ℝ1 s ) mkVal t i s = ( ℝ1 t, i, ℝ1 s )
mkI :: ( Double, Double ) -> 𝕀 Double mkI :: ( Double, Double ) -> 𝕀
mkI ( lo, hi ) = 𝕀 lo hi mkI ( lo, hi ) = 𝕀 lo hi
mkBox :: ( Double, Double ) -> ( Double, Double ) -> Box 2 mkBox :: ( Double, Double ) -> ( Double, Double ) -> Box 2
@ -255,7 +253,7 @@ potentialCusp
&& vx_min <= 0 && vx_max >= 0 && vx_min <= 0 && vx_max >= 0
&& vy_min <= 0 && vy_max >= 0 && vy_min <= 0 && vy_max >= 0
dEdsdcdt :: StrokeDatum k i -> D ( k - 2 ) ( I i ( ℝ 2 ) ) ( T ( I i ( ℝ 2 ) ) ) dEdsdcdt :: StrokeDatum k i -> D ( k - 2 ) ( I i 2 ) ( T ( I i 2 ) )
dEdsdcdt ( StrokeDatum { 𝛿E𝛿sdcdt = v } ) = v dEdsdcdt ( StrokeDatum { 𝛿E𝛿sdcdt = v } ) = v
width :: 𝕀ℝ 1 -> Double width :: 𝕀ℝ 1 -> Double

28
brush-strokes/src/cusps/inspect/Main.hs
View file

@ -75,42 +75,42 @@ data PointData params
outlineFunction outlineFunction
:: forall {t} (i :: t) brushParams :: forall {t} (i :: t) brushParams
. ( Show brushParams . ( Show brushParams
, D 1 ( I i ( ℝ 2 ) ) ~ D 1 ( ℝ 2 ) , D 1 ( I i 2 ) ~ D 1 ( ℝ 2 )
, D 2 ( I i ( ℝ 2 ) ) ~ D 2 ( ℝ 2 ) , D 2 ( I i 2 ) ~ D 2 ( ℝ 2 )
, D 3 ( I i ( ℝ 1 ) ) ~ D 3 ( ℝ 1 ) , D 3 ( I i 1 ) ~ D 3 ( ℝ 1 )
, D 3 ( I i ( ℝ 2 ) ) ~ D 3 ( ℝ 2 ) , D 3 ( I i 2 ) ~ D 3 ( ℝ 2 )
, HasType ( ℝ 2 ) ( PointData brushParams ) , HasType ( ℝ 2 ) ( PointData brushParams )
, Cross ( I i Double ) ( T ( I i ( ℝ 2 ) ) ) , Cross ( I i Double ) ( T ( I i 2 ) )
, Module ( I i Double ) ( T ( I i brushParams ) ) , Module ( I i Double ) ( T ( I i brushParams ) )
, Module Double (T brushParams) , Module Double (T brushParams)
, Torsor (T brushParams) brushParams , Torsor (T brushParams) brushParams
, Representable Double brushParams , Representable Double brushParams
, Torsor ( T ( I i ( ℝ 2 ) ) ) ( I i ( ℝ 2 ) ) , Torsor ( T ( I i 2 ) ) ( I i 2 )
, Torsor ( T ( I i brushParams ) ) ( I i brushParams ) , Torsor ( T ( I i brushParams ) ) ( I i brushParams )
, HasChainRule ( I i Double ) 3 ( I i ( ℝ 1 ) ) , HasChainRule ( I i Double ) 3 ( I i 1 )
, HasChainRule ( I i Double ) 3 ( I i brushParams ) , HasChainRule ( I i Double ) 3 ( I i brushParams )
, Traversable ( D 3 brushParams ) , Traversable ( D 3 brushParams )
, Traversable ( D 3 ( I i brushParams ) ) , Traversable ( D 3 ( I i brushParams ) )
, HasBézier 3 i , HasBézier 3 i
) )
=> ( I i Double -> I i ( ℝ 1 ) ) => ( I i Double -> I i 1 )
-> ( I i ( ℝ 1 ) -> I i Double ) -> ( I i 1 -> I i Double )
-> ( forall a. a -> I i a ) -> ( forall a. a -> I i a )
-> C 3 ( I i brushParams ) ( Spline Closed () ( I i ( ℝ 2 ) ) ) -> C 3 ( I i brushParams ) ( Spline Closed () ( I i 2 ) )
-- ^ brush shape -- ^ brush shape
-> Int -- ^ brush segment index to consider -> Int -- ^ brush segment index to consider
-> PointData brushParams -> Curve Open () ( PointData brushParams ) -> PointData brushParams -> Curve Open () ( PointData brushParams )
-- ^ stroke path -- ^ stroke path
-> ( I i ( ℝ 1 ) -> I i ( ℝ 1 ) -> StrokeDatum 3 i ) -> ( I i 1 -> I i 1 -> StrokeDatum 3 i )
outlineFunction co1 co2 single brush brush_index sp0 crv = strokeData outlineFunction co1 co2 single brush brush_index sp0 crv = strokeData
where where
path :: C 3 ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) path :: C 3 ( I i 1 ) ( I i 2 )
params :: C 3 ( I i ( ℝ 1 ) ) ( I i brushParams ) params :: C 3 ( I i 1 ) ( I i brushParams )
(path, params) = (path, params) =
pathAndUsedParams @3 @i co2 single brushParams sp0 crv pathAndUsedParams @3 @i co2 single brushParams sp0 crv
strokeData :: I i ( ℝ 1 ) -> I i ( ℝ 1 ) -> StrokeDatum 3 i strokeData :: I i 1 -> I i 1 -> StrokeDatum 3 i
strokeData = strokeData =
fmap ( `Seq.index` brush_index ) $ fmap ( `Seq.index` brush_index ) $
brushStrokeData @3 @brushParams co1 co2 path params brush brushStrokeData @3 @brushParams co1 co2 path params brush

6
brush-strokes/src/cusps/inspect/Math/Interval/Abstract.hs
View file

@ -421,7 +421,7 @@ normalise vars expr = case expr of
where where
expr' = Tabulate v' expr' = Tabulate v'
v' :: Vec n ( AI Double ) v' :: Vec n ( AI Double )
mxs :: Vec n ( Maybe ( 𝕀 Double ) ) mxs :: Vec n ( Maybe 𝕀 )
(v', mxs) = unzip $ fmap ( normalise vars ) v (v', mxs) = unzip $ fmap ( normalise vars ) v
Index iv i Index iv i
| Just r <- index_maybe iv' i | Just r <- index_maybe iv' i
@ -510,9 +510,9 @@ instance Transcendental ( AI Double ) where
sin = Sin sin = Sin
atan = Atan atan = Atan
class ( Eq v, Show v, Module ( 𝕀 Double ) ( T ( 𝕀 v ) ), Group ( T ( 𝕀 v ) ) ) class ( Eq v, Show v, Module 𝕀 ( T ( 𝕀 v ) ), Group ( T ( 𝕀 v ) ) )
=> IsVec v => IsVec v
instance ( Eq v, Show v, Module ( 𝕀 Double ) ( T ( 𝕀 v ) ), Group ( T ( 𝕀 v ) ) ) instance ( Eq v, Show v, Module 𝕀 ( T ( 𝕀 v ) ), Group ( T ( 𝕀 v ) ) )
=> IsVec v => IsVec v
instance IsVec v => Module ( AI Double ) ( T ( AI v ) ) where instance IsVec v => Module ( AI Double ) ( T ( AI v ) ) where

123
brush-strokes/src/lib/Calligraphy/Brushes.hs
View file

@ -17,7 +17,7 @@ import Prelude
hiding hiding
( Num(..), Floating(..), (^), (/), fromInteger, fromRational ) ( Num(..), Floating(..), (^), (/), fromInteger, fromRational )
import Data.Kind import Data.Kind
( Type ) ( Type, Constraint )
import GHC.Exts import GHC.Exts
( Proxy#, proxy# ) ( Proxy#, proxy# )
import GHC.TypeNats import GHC.TypeNats
@ -33,7 +33,7 @@ import Math.Bezier.Spline
import Math.Differentiable import Math.Differentiable
( I ) ( I )
import Math.Interval import Math.Interval
( 𝕀, singleton ) ( 𝕀, singleton, point )
import Math.Linear import Math.Linear
import Math.Module import Math.Module
( Module((^+^), (*^)) ) ( Module((^+^), (*^)) )
@ -42,32 +42,32 @@ import Math.Ring
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- | The shape of a brush (before applying any rotation). -- | The shape of a brush (before applying any rotation).
type BrushFn :: forall {kd}. kd -> Nat -> Type -> Type type BrushFn :: forall {kd}. kd -> Nat -> Nat -> Type
type BrushFn i k brushParams type BrushFn i k nbBrushParams
= C k ( I i brushParams ) = C k ( I i nbBrushParams )
( Spline Closed () ( I i ( ℝ 2 ) ) ) ( Spline Closed () ( I i 2 ) )
-- | A brush, described as a base shape + an optional rotation. -- | A brush, described as a base shape + an optional rotation.
data Brush brushParams data Brush nbBrushParams
= Brush = Brush
{ -- | Base brush shape, before applying any rotation (if any). { -- | Base brush shape, before applying any rotation (if any).
brushBaseShape :: BrushFn () 2 brushParams brushBaseShape :: BrushFn ℝ 2 nbBrushParams
-- | Base brush shape, before applying any rotation (if any). -- | Base brush shape, before applying any rotation (if any).
, brushBaseShapeI :: BrushFn 𝕀 3 brushParams , brushBaseShapeI :: BrushFn 𝕀 3 nbBrushParams
-- | Optional rotation angle function -- | Optional rotation angle function
-- (assumed to be a linear function). -- (assumed to be a linear function).
, mbRotation :: Maybe ( brushParams -> Double ) , mbRotation :: Maybe ( ℝ nbBrushParams -> Double )
} }
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- Brushes -- Brushes
-- Some convenience type synonyms for brush types... a bit horrible -- Some convenience type synonyms for brush types... a bit horrible
type ParamsCt rec = ( ParamsICt 2 () rec, ParamsICt 3 𝕀 rec ) type ParamsICt :: Nat -> k -> Nat -> Constraint
type ParamsICt k i rec = type ParamsICt k i rec =
( Module ( Module
( D k ( I i rec ) ( I i Double ) ) ( D k ( I i rec ) ( I i Double ) )
( D k ( I i rec ) ( I i ( ℝ 2 ) ) ) ( D k ( I i rec ) ( I i 2 ) )
, Module ( I i Double ) ( T ( I i Double ) ) , Module ( I i Double ) ( T ( I i Double ) )
, HasChainRule ( I i Double ) k ( I i rec ) , HasChainRule ( I i Double ) k ( I i rec )
, Representable ( I i Double ) ( I i rec ) , Representable ( I i Double ) ( I i rec )
@ -75,29 +75,29 @@ type ParamsICt k i rec =
) )
{-# INLINEABLE circleBrush #-} {-# INLINEABLE circleBrush #-}
circleBrush :: ( 1 <= RepDim params, ParamsCt params ) => Brush params circleBrush :: Brush 1
circleBrush = circleBrush =
Brush Brush
{ brushBaseShape = circleBrushFn @() @2 proxy# id { brushBaseShape = circleBrushFn @ℝ @2 @1 proxy# id id
, brushBaseShapeI = circleBrushFn @𝕀 @3 proxy# singleton , brushBaseShapeI = circleBrushFn @𝕀 @3 @1 proxy# singleton point
, mbRotation = Nothing , mbRotation = Nothing
} }
{-# INLINEABLE ellipseBrush #-} {-# INLINEABLE ellipseBrush #-}
ellipseBrush :: ( 3 <= RepDim params, ParamsCt params ) => Brush params ellipseBrush :: Brush 3
ellipseBrush = ellipseBrush =
Brush Brush
{ brushBaseShape = ellipseBrushFn @() @2 proxy# id { brushBaseShape = ellipseBrushFn @ℝ @2 @3 proxy# id id
, brushBaseShapeI = ellipseBrushFn @𝕀 @3 proxy# singleton , brushBaseShapeI = ellipseBrushFn @𝕀 @3 @3 proxy# singleton point
, mbRotation = Just ( `index` ( Fin 3 ) ) , mbRotation = Just ( `index` ( Fin 3 ) )
} }
{-# INLINEABLE tearDropBrush #-} {-# INLINEABLE tearDropBrush #-}
tearDropBrush :: ( 3 <= RepDim params, ParamsCt params ) => Brush params tearDropBrush :: Brush 3
tearDropBrush = tearDropBrush =
Brush Brush
{ brushBaseShape = tearDropBrushFn @() @2 proxy# id { brushBaseShape = tearDropBrushFn @ℝ @2 @3 proxy# id id
, brushBaseShapeI = tearDropBrushFn @𝕀 @3 proxy# singleton , brushBaseShapeI = tearDropBrushFn @𝕀 @3 @3 proxy# singleton point
, mbRotation = Just ( `index` ( Fin 3 ) ) , mbRotation = Just ( `index` ( Fin 3 ) )
} }
@ -127,54 +127,59 @@ circleSpline p = sequenceA $
Bezier3To ( p κ -1 ) ( p 1 -κ ) BackToStart () Bezier3To ( p κ -1 ) ( p 1 -κ ) BackToStart ()
{-# INLINE circleSpline #-} {-# INLINE circleSpline #-}
circleBrushFn :: forall {t} (i :: t) k rec circleBrushFn :: forall {t} (i :: t) k nbParams
. ( 1 <= RepDim ( I i rec ) . ( 1 <= nbParams
, ParamsICt k i rec , ParamsICt k i nbParams
) )
=> Proxy# i => Proxy# i
-> ( forall a. a -> I i a ) -> ( Double -> I i Double )
-> C k ( I i rec ) ( Spline 'Closed () ( I i ( ℝ 2 ) ) ) -> ( I ℝ 2 -> I i 2 )
circleBrushFn _ mkI = -> C k ( I i nbParams ) ( Spline 'Closed () ( I i 2 ) )
circleBrushFn _ mkI1 mkI2 =
D \ params -> D \ params ->
let r :: D k ( I i rec ) ( I i Double ) let r :: D k ( I i nbParams ) ( I i Double )
r = runD ( var @_ @k $ Fin 1 ) params r = runD ( var @_ @k $ Fin 1 ) params
mkPt :: Double -> Double -> D k ( I i rec ) ( I i ( ℝ 2 ) ) mkPt :: Double -> Double -> D k ( I i nbParams ) ( I i 2 )
mkPt x y mkPt x y
= ( r `scaledBy` x ) *^ e_x = ( r `scaledBy` x ) *^ e_x
^+^ ( r `scaledBy` y ) *^ e_y ^+^ ( r `scaledBy` y ) *^ e_y
in circleSpline mkPt in circleSpline mkPt
where where
e_x, e_y :: D k ( I i rec ) ( I i ( ℝ 2 ) ) e_x, e_y :: D k ( I i nbParams ) ( I i 2 )
e_x = pure $ mkI $ ℝ2 1 0 e_x = pure $ mkI2 $ ℝ2 1 0
e_y = pure $ mkI $ ℝ2 0 1 e_y = pure $ mkI2 $ ℝ2 0 1
scaledBy d x = fmap ( mkI x * ) d scaledBy :: D k ( I i nbParams ) ( I i Double ) -> Double -> D k ( I i nbParams ) ( I i Double )
scaledBy d x = fmap ( mkI1 x * ) d
{-# INLINEABLE circleBrushFn #-} {-# INLINEABLE circleBrushFn #-}
ellipseBrushFn :: forall {t} (i :: t) k rec ellipseBrushFn :: forall {t} (i :: t) k nbParams
. ( 3 <= RepDim ( I i rec ) . ( 3 <= nbParams
, ParamsICt k i rec , ParamsICt k i nbParams
) )
=> Proxy# i => Proxy# i
-> ( forall a. a -> I i a ) -> ( Double -> I i Double )
-> C k ( I i rec ) ( Spline 'Closed () ( I i ( ℝ 2 ) ) ) -> ( I ℝ 2 -> I i 2 )
ellipseBrushFn _ mkI =
-> C k ( I i nbParams ) ( Spline 'Closed () ( I i 2 ) )
ellipseBrushFn _ mkI1 mkI2 =
D \ params -> D \ params ->
let a, b :: D k ( I i rec ) ( I i Double ) let a, b :: D k ( I i nbParams ) ( I i Double )
a = runD ( var @_ @k $ Fin 1 ) params a = runD ( var @_ @k $ Fin 1 ) params
b = runD ( var @_ @k $ Fin 2 ) params b = runD ( var @_ @k $ Fin 2 ) params
mkPt :: Double -> Double -> D k ( I i rec ) ( I i ( ℝ 2 ) ) mkPt :: Double -> Double -> D k ( I i nbParams ) ( I i 2 )
mkPt x y mkPt x y
= let !x' = a `scaledBy` x = let !x' = a `scaledBy` x
!y' = b `scaledBy` y !y' = b `scaledBy` y
in x' *^ e_x ^+^ y' *^ e_y in x' *^ e_x ^+^ y' *^ e_y
in circleSpline mkPt in circleSpline mkPt
where where
e_x, e_y :: D k ( I i rec ) ( I i ( ℝ 2 ) ) e_x, e_y :: D k ( I i nbParams ) ( I i 2 )
e_x = pure $ mkI $ ℝ2 1 0 e_x = pure $ mkI2 $ ℝ2 1 0
e_y = pure $ mkI $ ℝ2 0 1 e_y = pure $ mkI2 $ ℝ2 0 1
scaledBy d x = fmap ( mkI x * ) d scaledBy :: D k ( I i nbParams ) ( I i Double ) -> Double -> D k ( I i nbParams ) ( I i Double )
scaledBy d x = fmap ( mkI1 x * ) d
{-# INLINEABLE ellipseBrushFn #-} {-# INLINEABLE ellipseBrushFn #-}
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
@ -197,19 +202,20 @@ tearHeight = 3 * sqrt 3 / 8
sqrt3_over_2 :: Double sqrt3_over_2 :: Double
sqrt3_over_2 = 0.5 * sqrt 3 sqrt3_over_2 = 0.5 * sqrt 3
tearDropBrushFn :: forall {t} (i :: t) k rec tearDropBrushFn :: forall {t} (i :: t) k nbParams
. ( 3 <= RepDim ( I i rec ) . ( 3 <= nbParams
, ParamsICt k i rec , ParamsICt k i nbParams
) )
=> Proxy# i => Proxy# i
-> ( forall a. a -> I i a ) -> ( Double -> I i Double )
-> C k ( I i rec ) ( Spline 'Closed () ( I i ( ℝ 2 ) ) ) -> ( I ℝ 2 -> I i 2 )
tearDropBrushFn _ mkI = -> C k ( I i nbParams ) ( Spline 'Closed () ( I i 2 ) )
tearDropBrushFn _ mkI1 mkI2 =
D \ params -> D \ params ->
let w, h :: D k ( I i rec ) ( I i Double ) let w, h :: D k ( I i nbParams ) ( I i Double )
w = runD ( var @_ @k ( Fin 1 ) ) params w = runD ( var @_ @k ( Fin 1 ) ) params
h = runD ( var @_ @k ( Fin 2 ) ) params h = runD ( var @_ @k ( Fin 2 ) ) params
mkPt :: Double -> Double -> D k ( I i rec ) ( I i ( ℝ 2 ) ) mkPt :: Double -> Double -> D k ( I i nbParams ) ( I i 2 )
mkPt x y mkPt x y
-- 1. translate the teardrop so that the centre of mass is at the origin -- 1. translate the teardrop so that the centre of mass is at the origin
-- 2. scale the teardrop so that it has the requested width/height -- 2. scale the teardrop so that it has the requested width/height
@ -226,9 +232,10 @@ tearDropBrushFn _ mkI =
( mkPt -0.5 sqrt3_over_2 ) ( mkPt -0.5 sqrt3_over_2 )
BackToStart () } BackToStart () }
where where
e_x, e_y :: D k ( I i rec ) ( I i ( ℝ 2 ) ) e_x, e_y :: D k ( I i nbParams ) ( I i 2 )
e_x = pure $ mkI $ ℝ2 1 0 e_x = pure $ mkI2 $ ℝ2 1 0
e_y = pure $ mkI $ ℝ2 0 1 e_y = pure $ mkI2 $ ℝ2 0 1
scaledBy d x = fmap ( mkI x * ) d scaledBy :: D k ( I i nbParams ) ( I i Double ) -> Double -> D k ( I i nbParams ) ( I i Double )
scaledBy d x = fmap ( mkI1 x * ) d
{-# INLINEABLE tearDropBrushFn #-} {-# INLINEABLE tearDropBrushFn #-}

64
brush-strokes/src/lib/Math/Algebra/Dual.hs
View file

@ -289,7 +289,7 @@ instance Ring r => Ring ( D2𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D2𝔸1 Double ) #-} {-# SPECIALISE instance Ring ( D2𝔸1 Double ) #-}
{-# SPECIALISE instance Ring ( D2𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D2𝔸1 𝕀 ) #-}
instance Ring r => Ring ( D2𝔸2 r ) where instance Ring r => Ring ( D2𝔸2 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -314,7 +314,7 @@ instance Ring r => Ring ( D2𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D2𝔸2 Double ) #-} {-# SPECIALISE instance Ring ( D2𝔸2 Double ) #-}
{-# SPECIALISE instance Ring ( D2𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D2𝔸2 𝕀 ) #-}
instance Ring r => Ring ( D2𝔸3 r ) where instance Ring r => Ring ( D2𝔸3 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -339,7 +339,7 @@ instance Ring r => Ring ( D2𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D2𝔸3 Double ) #-} {-# SPECIALISE instance Ring ( D2𝔸3 Double ) #-}
{-# SPECIALISE instance Ring ( D2𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D2𝔸3 𝕀 ) #-}
instance Ring r => Ring ( D2𝔸4 r ) where instance Ring r => Ring ( D2𝔸4 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -364,7 +364,7 @@ instance Ring r => Ring ( D2𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D2𝔸4 Double ) #-} {-# SPECIALISE instance Ring ( D2𝔸4 Double ) #-}
{-# SPECIALISE instance Ring ( D2𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D2𝔸4 𝕀 ) #-}
instance Ring r => Ring ( D3𝔸1 r ) where instance Ring r => Ring ( D3𝔸1 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -389,7 +389,7 @@ instance Ring r => Ring ( D3𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D3𝔸1 Double ) #-} {-# SPECIALISE instance Ring ( D3𝔸1 Double ) #-}
{-# SPECIALISE instance Ring ( D3𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D3𝔸1 𝕀 ) #-}
instance Ring r => Ring ( D3𝔸2 r ) where instance Ring r => Ring ( D3𝔸2 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -414,7 +414,7 @@ instance Ring r => Ring ( D3𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D3𝔸2 Double ) #-} {-# SPECIALISE instance Ring ( D3𝔸2 Double ) #-}
{-# SPECIALISE instance Ring ( D3𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D3𝔸2 𝕀 ) #-}
instance Ring r => Ring ( D3𝔸3 r ) where instance Ring r => Ring ( D3𝔸3 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -439,7 +439,7 @@ instance Ring r => Ring ( D3𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D3𝔸3 Double ) #-} {-# SPECIALISE instance Ring ( D3𝔸3 Double ) #-}
{-# SPECIALISE instance Ring ( D3𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D3𝔸3 𝕀 ) #-}
instance Ring r => Ring ( D3𝔸4 r ) where instance Ring r => Ring ( D3𝔸4 r ) where
!dr1 * !dr2 = !dr1 * !dr2 =
@ -464,7 +464,7 @@ instance Ring r => Ring ( D3𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Ring ( D3𝔸4 Double ) #-} {-# SPECIALISE instance Ring ( D3𝔸4 Double ) #-}
{-# SPECIALISE instance Ring ( D3𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Ring ( D3𝔸4 𝕀 ) #-}
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- Field, floating & transcendental instances -- Field, floating & transcendental instances
@ -503,7 +503,7 @@ instance Field r => Field ( D2𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D2𝔸1 Double ) #-} {-# SPECIALISE instance Field ( D2𝔸1 Double ) #-}
{-# SPECIALISE instance Field ( D2𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D2𝔸1 𝕀 ) #-}
instance Field r => Field ( D2𝔸2 r ) where instance Field r => Field ( D2𝔸2 r ) where
fromRational q = konst @Double @2 @( ℝ 2 ) ( fromRational q ) fromRational q = konst @Double @2 @( ℝ 2 ) ( fromRational q )
recip df = recip df =
@ -516,7 +516,7 @@ instance Field r => Field ( D2𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D2𝔸2 Double ) #-} {-# SPECIALISE instance Field ( D2𝔸2 Double ) #-}
{-# SPECIALISE instance Field ( D2𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D2𝔸2 𝕀 ) #-}
instance Field r => Field ( D2𝔸3 r ) where instance Field r => Field ( D2𝔸3 r ) where
fromRational q = konst @Double @2 @( ℝ 3 ) ( fromRational q ) fromRational q = konst @Double @2 @( ℝ 3 ) ( fromRational q )
recip df = recip df =
@ -529,7 +529,7 @@ instance Field r => Field ( D2𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D2𝔸3 Double ) #-} {-# SPECIALISE instance Field ( D2𝔸3 Double ) #-}
{-# SPECIALISE instance Field ( D2𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D2𝔸3 𝕀 ) #-}
instance Field r => Field ( D2𝔸4 r ) where instance Field r => Field ( D2𝔸4 r ) where
fromRational q = konst @Double @2 @( ℝ 4 ) ( fromRational q ) fromRational q = konst @Double @2 @( ℝ 4 ) ( fromRational q )
recip df = recip df =
@ -542,7 +542,7 @@ instance Field r => Field ( D2𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D2𝔸4 Double ) #-} {-# SPECIALISE instance Field ( D2𝔸4 Double ) #-}
{-# SPECIALISE instance Field ( D2𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D2𝔸4 𝕀 ) #-}
instance Field r => Field ( D3𝔸1 r ) where instance Field r => Field ( D3𝔸1 r ) where
fromRational q = konst @Double @3 @( ℝ 1 ) ( fromRational q ) fromRational q = konst @Double @3 @( ℝ 1 ) ( fromRational q )
recip df = recip df =
@ -555,7 +555,7 @@ instance Field r => Field ( D3𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D3𝔸1 Double ) #-} {-# SPECIALISE instance Field ( D3𝔸1 Double ) #-}
{-# SPECIALISE instance Field ( D3𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D3𝔸1 𝕀 ) #-}
instance Field r => Field ( D3𝔸2 r ) where instance Field r => Field ( D3𝔸2 r ) where
fromRational q = konst @Double @3 @( ℝ 2 ) ( fromRational q ) fromRational q = konst @Double @3 @( ℝ 2 ) ( fromRational q )
recip df = recip df =
@ -568,7 +568,7 @@ instance Field r => Field ( D3𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D3𝔸2 Double ) #-} {-# SPECIALISE instance Field ( D3𝔸2 Double ) #-}
{-# SPECIALISE instance Field ( D3𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D3𝔸2 𝕀 ) #-}
instance Field r => Field ( D3𝔸3 r ) where instance Field r => Field ( D3𝔸3 r ) where
fromRational q = konst @Double @3 @( ℝ 3 ) ( fromRational q ) fromRational q = konst @Double @3 @( ℝ 3 ) ( fromRational q )
recip df = recip df =
@ -581,7 +581,7 @@ instance Field r => Field ( D3𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D3𝔸3 Double ) #-} {-# SPECIALISE instance Field ( D3𝔸3 Double ) #-}
{-# SPECIALISE instance Field ( D3𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D3𝔸3 𝕀 ) #-}
instance Field r => Field ( D3𝔸4 r ) where instance Field r => Field ( D3𝔸4 r ) where
fromRational q = konst @Double @3 @( ℝ 4 ) ( fromRational q ) fromRational q = konst @Double @3 @( ℝ 4 ) ( fromRational q )
recip df = recip df =
@ -594,7 +594,7 @@ instance Field r => Field ( D3𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Field ( D3𝔸4 Double ) #-} {-# SPECIALISE instance Field ( D3𝔸4 Double ) #-}
{-# SPECIALISE instance Field ( D3𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Field ( D3𝔸4 𝕀 ) #-}
d1sqrt :: Floating r => r -> D1𝔸1 r d1sqrt :: Floating r => r -> D1𝔸1 r
d1sqrt x = d1sqrt x =
@ -631,7 +631,7 @@ instance Floating r => Floating ( D2𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D2𝔸1 Double ) #-} {-# SPECIALISE instance Floating ( D2𝔸1 Double ) #-}
{-# SPECIALISE instance Floating ( D2𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D2𝔸1 𝕀 ) #-}
instance Floating r => Floating ( D2𝔸2 r ) where instance Floating r => Floating ( D2𝔸2 r ) where
sqrt df = sqrt df =
let let
@ -643,7 +643,7 @@ instance Floating r => Floating ( D2𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D2𝔸2 Double ) #-} {-# SPECIALISE instance Floating ( D2𝔸2 Double ) #-}
{-# SPECIALISE instance Floating ( D2𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D2𝔸2 𝕀 ) #-}
instance Floating r => Floating ( D2𝔸3 r ) where instance Floating r => Floating ( D2𝔸3 r ) where
sqrt df = sqrt df =
let let
@ -655,7 +655,7 @@ instance Floating r => Floating ( D2𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D2𝔸3 Double ) #-} {-# SPECIALISE instance Floating ( D2𝔸3 Double ) #-}
{-# SPECIALISE instance Floating ( D2𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D2𝔸3 𝕀 ) #-}
instance Floating r => Floating ( D2𝔸4 r ) where instance Floating r => Floating ( D2𝔸4 r ) where
sqrt df = sqrt df =
let let
@ -667,7 +667,7 @@ instance Floating r => Floating ( D2𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D2𝔸4 Double ) #-} {-# SPECIALISE instance Floating ( D2𝔸4 Double ) #-}
{-# SPECIALISE instance Floating ( D2𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D2𝔸4 𝕀 ) #-}
instance Floating r => Floating ( D3𝔸1 r ) where instance Floating r => Floating ( D3𝔸1 r ) where
sqrt df = sqrt df =
let let
@ -679,7 +679,7 @@ instance Floating r => Floating ( D3𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D3𝔸1 Double ) #-} {-# SPECIALISE instance Floating ( D3𝔸1 Double ) #-}
{-# SPECIALISE instance Floating ( D3𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D3𝔸1 𝕀 ) #-}
instance Floating r => Floating ( D3𝔸2 r ) where instance Floating r => Floating ( D3𝔸2 r ) where
sqrt df = sqrt df =
let let
@ -691,7 +691,7 @@ instance Floating r => Floating ( D3𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D3𝔸2 Double ) #-} {-# SPECIALISE instance Floating ( D3𝔸2 Double ) #-}
{-# SPECIALISE instance Floating ( D3𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D3𝔸2 𝕀 ) #-}
instance Floating r => Floating ( D3𝔸3 r ) where instance Floating r => Floating ( D3𝔸3 r ) where
sqrt df = sqrt df =
let let
@ -703,7 +703,7 @@ instance Floating r => Floating ( D3𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D3𝔸3 Double ) #-} {-# SPECIALISE instance Floating ( D3𝔸3 Double ) #-}
{-# SPECIALISE instance Floating ( D3𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D3𝔸3 𝕀 ) #-}
instance Floating r => Floating ( D3𝔸4 r ) where instance Floating r => Floating ( D3𝔸4 r ) where
sqrt df = sqrt df =
let let
@ -715,7 +715,7 @@ instance Floating r => Floating ( D3𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Floating ( D3𝔸4 Double ) #-} {-# SPECIALISE instance Floating ( D3𝔸4 Double ) #-}
{-# SPECIALISE instance Floating ( D3𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Floating ( D3𝔸4 𝕀 ) #-}
d1sin, d1cos, d1atan :: Transcendental r => r -> D1𝔸1 r d1sin, d1cos, d1atan :: Transcendental r => r -> D1𝔸1 r
d1sin x = d1sin x =
@ -809,7 +809,7 @@ instance Transcendental r => Transcendental ( D2𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D2𝔸1 Double ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸1 Double ) #-}
{-# SPECIALISE instance Transcendental ( D2𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸1 𝕀 ) #-}
instance Transcendental r => Transcendental ( D2𝔸2 r ) where instance Transcendental r => Transcendental ( D2𝔸2 r ) where
pi = konst @Double @2 @( ℝ 2 ) pi pi = konst @Double @2 @( ℝ 2 ) pi
sin df = sin df =
@ -840,7 +840,7 @@ instance Transcendental r => Transcendental ( D2𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D2𝔸2 Double ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸2 Double ) #-}
{-# SPECIALISE instance Transcendental ( D2𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸2 𝕀 ) #-}
instance Transcendental r => Transcendental ( D2𝔸3 r ) where instance Transcendental r => Transcendental ( D2𝔸3 r ) where
pi = konst @Double @2 @( ℝ 3 ) pi pi = konst @Double @2 @( ℝ 3 ) pi
sin df = sin df =
@ -871,7 +871,7 @@ instance Transcendental r => Transcendental ( D2𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D2𝔸3 Double ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸3 Double ) #-}
{-# SPECIALISE instance Transcendental ( D2𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸3 𝕀 ) #-}
instance Transcendental r => Transcendental ( D2𝔸4 r ) where instance Transcendental r => Transcendental ( D2𝔸4 r ) where
pi = konst @Double @2 @( ℝ 4 ) pi pi = konst @Double @2 @( ℝ 4 ) pi
@ -903,7 +903,7 @@ instance Transcendental r => Transcendental ( D2𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D2𝔸4 Double ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸4 Double ) #-}
{-# SPECIALISE instance Transcendental ( D2𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D2𝔸4 𝕀 ) #-}
instance Transcendental r => Transcendental ( D3𝔸1 r ) where instance Transcendental r => Transcendental ( D3𝔸1 r ) where
pi = konst @Double @3 @( ℝ 1 ) pi pi = konst @Double @3 @( ℝ 1 ) pi
@ -935,7 +935,7 @@ instance Transcendental r => Transcendental ( D3𝔸1 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D3𝔸1 Double ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸1 Double ) #-}
{-# SPECIALISE instance Transcendental ( D3𝔸1 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸1 𝕀 ) #-}
instance Transcendental r => Transcendental ( D3𝔸2 r ) where instance Transcendental r => Transcendental ( D3𝔸2 r ) where
pi = konst @Double @3 @( ℝ 2 ) pi pi = konst @Double @3 @( ℝ 2 ) pi
@ -967,7 +967,7 @@ instance Transcendental r => Transcendental ( D3𝔸2 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D3𝔸2 Double ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸2 Double ) #-}
{-# SPECIALISE instance Transcendental ( D3𝔸2 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸2 𝕀 ) #-}
instance Transcendental r => Transcendental ( D3𝔸3 r ) where instance Transcendental r => Transcendental ( D3𝔸3 r ) where
pi = konst @Double @3 @( ℝ 3 ) pi pi = konst @Double @3 @( ℝ 3 ) pi
@ -999,7 +999,7 @@ instance Transcendental r => Transcendental ( D3𝔸3 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D3𝔸3 Double ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸3 Double ) #-}
{-# SPECIALISE instance Transcendental ( D3𝔸3 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸3 𝕀 ) #-}
instance Transcendental r => Transcendental ( D3𝔸4 r ) where instance Transcendental r => Transcendental ( D3𝔸4 r ) where
pi = konst @Double @3 @( ℝ 4 ) pi pi = konst @Double @3 @( ℝ 4 ) pi
@ -1031,7 +1031,7 @@ instance Transcendental r => Transcendental ( D3𝔸4 r ) where
in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||] in $$( chainRuleN1Q [|| fromInt ||] [|| add ||] [|| times ||] [|| pow ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
{-# SPECIALISE instance Transcendental ( D3𝔸4 Double ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸4 Double ) #-}
{-# SPECIALISE instance Transcendental ( D3𝔸4 ( 𝕀 Double ) ) #-} {-# SPECIALISE instance Transcendental ( D3𝔸4 𝕀 ) #-}
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- HasChainRule instances. -- HasChainRule instances.

316
brush-strokes/src/lib/Math/Bezier/Stroke.hs
View file

@ -62,7 +62,7 @@ import GHC.STRef
import GHC.Generics import GHC.Generics
( Generic, Generic1, Generically(..) ) ( Generic, Generic1, Generically(..) )
import GHC.TypeNats import GHC.TypeNats
( type (-) ) ( Nat, type (-) )
-- acts -- acts
import Data.Act import Data.Act
@ -229,34 +229,35 @@ data OutlineInfo =
type N = 2 type N = 2
computeStrokeOutline :: computeStrokeOutline ::
forall ( clo :: SplineType ) usedParams brushParams crvData ptData s forall ( clo :: SplineType ) ( nbUsedParams :: Nat ) ( nbBrushParams :: Nat ) crvData ptData s
. ( KnownSplineType clo . ( KnownSplineType clo
, HasType ( ℝ 2 ) ptData , HasType ( ℝ 2 ) ptData
, HasType ( CachedStroke s ) crvData , HasType ( CachedStroke s ) crvData
, NFData ptData, NFData crvData , NFData ptData, NFData crvData
-- Differentiability. -- Differentiability.
, Interpolatable Double usedParams , Interpolatable Double ( ℝ nbUsedParams )
, Interpolatable ( 𝕀 Double ) ( 𝕀 usedParams ) , DiffInterp 2 ℝ nbBrushParams
, DiffInterp 2 () brushParams , DiffInterp 3 𝕀 nbBrushParams
, DiffInterp 3 𝕀 brushParams , HasChainRule Double 2 ( ℝ nbUsedParams )
, HasChainRule Double 2 usedParams , HasChainRule 𝕀 3 ( 𝕀ℝ nbUsedParams )
, HasChainRule ( 𝕀 Double ) 3 ( 𝕀 usedParams ) , HasChainRule Double 2 ( ℝ nbBrushParams )
, HasChainRule Double 2 brushParams , HasChainRule 𝕀 3 ( 𝕀ℝ nbBrushParams )
, HasChainRule ( 𝕀 Double ) 3 ( 𝕀 brushParams ) , Traversable ( D 2 ( ℝ nbBrushParams ) )
, Traversable ( D 2 brushParams ) , Representable Double ( ℝ nbUsedParams )
, Representable Double usedParams , Representable 𝕀 ( 𝕀ℝ nbUsedParams )
, Module 𝕀 (T (𝕀ℝ nbUsedParams))
-- Debugging. -- Debugging.
, Show ptData, Show brushParams , Show ptData, Show ( ℝ nbBrushParams )
) )
=> RootSolvingAlgorithm => RootSolvingAlgorithm
-> Maybe ( RootIsolationOptions N 3 ) -> Maybe ( RootIsolationOptions N 3 )
-> FitParameters -> FitParameters
-> ( ptData -> usedParams ) -> ( ptData -> ℝ nbUsedParams )
-> ( usedParams -> brushParams ) -- ^ assumed to be linear and non-decreasing -> ( ℝ nbUsedParams -> ℝ nbBrushParams ) -- ^ assumed to be linear and non-decreasing
-> Brush brushParams -> Brush nbBrushParams
-> Spline clo crvData ptData -> Spline clo crvData ptData
-> ST s -> ST s
( Either ( SplinePts Closed ) ( SplinePts Closed, SplinePts Closed ) ( Either ( SplinePts Closed ) ( SplinePts Closed, SplinePts Closed )
@ -514,31 +515,32 @@ computeStrokeOutline rootAlgo mbCuspOptions fitParams ptParams toBrushParams bru
-- | Computes the forward and backward stroke outline functions for a single curve. -- | Computes the forward and backward stroke outline functions for a single curve.
outlineFunction outlineFunction
:: forall usedParams brushParams crvData ptData :: forall (nbUsedParams :: Nat) (nbBrushParams :: Nat) crvData ptData
. ( HasType ( ℝ 2 ) ptData . ( HasType ( ℝ 2 ) ptData
-- Differentiability. -- Differentiability.
, Interpolatable Double usedParams , Interpolatable Double ( ℝ nbUsedParams )
, Interpolatable ( 𝕀 Double ) ( 𝕀 usedParams ) , DiffInterp 2 ℝ nbBrushParams
, DiffInterp 2 () brushParams , DiffInterp 3 𝕀 nbBrushParams
, DiffInterp 3 𝕀 brushParams , HasChainRule Double 2 ( ℝ nbUsedParams )
, HasChainRule Double 2 usedParams , HasChainRule 𝕀 3 ( 𝕀ℝ nbUsedParams )
, HasChainRule ( 𝕀 Double ) 3 ( 𝕀 usedParams ) , HasChainRule Double 2 ( ℝ nbBrushParams )
, HasChainRule Double 2 brushParams , HasChainRule 𝕀 3 ( 𝕀ℝ nbBrushParams )
, HasChainRule ( 𝕀 Double ) 3 ( 𝕀 brushParams ) , Traversable ( D 2 ( ℝ nbBrushParams ) )
, Traversable ( D 2 brushParams ) , Module 𝕀 (T (𝕀ℝ nbUsedParams))
-- Computing AABBs -- Computing AABBs
, Representable Double usedParams , Representable Double ( ℝ nbUsedParams )
, Representable 𝕀 ( 𝕀ℝ nbUsedParams )
-- Debugging. -- Debugging.
, Show ptData, Show brushParams , Show ptData, Show ( ℝ nbBrushParams )
) )
=> RootSolvingAlgorithm => RootSolvingAlgorithm
-> Maybe ( RootIsolationOptions N 3 ) -> Maybe ( RootIsolationOptions N 3 )
-> ( ptData -> usedParams ) -> ( ptData -> ℝ nbUsedParams )
-> ( usedParams -> brushParams ) -- ^ assumed to be linear and non-decreasing -> ( ℝ nbUsedParams -> ℝ nbBrushParams ) -- ^ assumed to be linear and non-decreasing
-> Brush brushParams -> Brush nbBrushParams
-> ptData -> ptData
-> Curve Open crvData ptData -> Curve Open crvData ptData
-> OutlineInfo -> OutlineInfo
@ -546,15 +548,15 @@ outlineFunction rootAlgo mbCuspOptions ptParams toBrushParams
( Brush { brushBaseShape, brushBaseShapeI, mbRotation } ) = \ sp0 crv -> ( Brush { brushBaseShape, brushBaseShapeI, mbRotation } ) = \ sp0 crv ->
let let
usedParams :: C 2 ( ℝ 1 ) usedParams usedParams :: C 2 ( ℝ 1 ) ( ℝ nbUsedParams )
path :: C 2 ( ℝ 1 ) ( ℝ 2 ) path :: C 2 ( ℝ 1 ) ( ℝ 2 )
( path, usedParams ) ( path, usedParams )
= pathAndUsedParams @2 @() coerce id ptParams sp0 crv = pathAndUsedParams @2 @ℝ @nbUsedParams coerce id id ptParams sp0 crv
curves :: ℝ 1 -- t curves :: ℝ 1 -- t
-> Seq ( ℝ 1 {- s -} -> StrokeDatum 2 () ) -> Seq ( ℝ 1 {- s -} -> StrokeDatum 2 ℝ )
curves = curves =
brushStrokeData @2 @brushParams brushStrokeData @2 @nbBrushParams
coerce coerce coerce coerce
path path
( fmap toBrushParams usedParams ) ( fmap toBrushParams usedParams )
@ -564,16 +566,16 @@ outlineFunction rootAlgo mbCuspOptions ptParams toBrushParams
curvesI :: 𝕀ℝ 1 -- t curvesI :: 𝕀ℝ 1 -- t
-> Seq ( 𝕀ℝ 1 {- s -} -> StrokeDatum 3 𝕀 ) -> Seq ( 𝕀ℝ 1 {- s -} -> StrokeDatum 3 𝕀 )
curvesI = curvesI =
brushStrokeData @3 @brushParams brushStrokeData @3 @nbBrushParams
coerce coerce coerce coerce
pathI pathI
( fmap ( nonDecreasing toBrushParams ) usedParamsI ) ( fmap ( nonDecreasing toBrushParams ) usedParamsI )
brushBaseShapeI brushBaseShapeI
( fmap nonDecreasing mbRotation ) ( fmap ( \ rot -> un𝕀ℝ1 . nonDecreasing ( ℝ1 . rot ) ) mbRotation )
usedParamsI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀 usedParams ) usedParamsI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ nbUsedParams )
pathI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) pathI :: C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 )
( pathI, usedParamsI ) = pathAndUsedParams @3 @𝕀 coerce singleton ptParams sp0 crv ( pathI, usedParamsI ) = pathAndUsedParams @3 @𝕀 @nbUsedParams coerce point point ptParams sp0 crv
fwdBwd :: OutlineFn fwdBwd :: OutlineFn
fwdBwd t fwdBwd t
@ -597,7 +599,7 @@ outlineFunction rootAlgo mbCuspOptions ptParams toBrushParams
in fmap ( unT . rotate cosθ sinθ . T ) in fmap ( unT . rotate cosθ sinθ . T )
in in
applyRot $ applyRot $
value @Double @2 @brushParams $ value @Double @2 @( ℝ nbBrushParams ) $
runD brushBaseShape brushParams runD brushBaseShape brushParams
( potentialCusps, definiteCusps ) = ( potentialCusps, definiteCusps ) =
@ -618,39 +620,41 @@ outlineFunction rootAlgo mbCuspOptions ptParams toBrushParams
} }
{-# INLINEABLE outlineFunction #-} {-# INLINEABLE outlineFunction #-}
pathAndUsedParams :: forall k i arr crvData ptData usedParams pathAndUsedParams :: forall k i (nbUsedParams :: Nat) arr crvData ptData
. ( HasType ( ℝ 2 ) ptData . ( HasType ( ℝ 2 ) ptData
, HasBézier k i , HasBézier k i
, arr ~ C k , arr ~ C k
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , D k ( I i 1 ) ~ D k ( ℝ 1 )
, Module ( I i Double ) ( T ( I i ( ℝ 2 ) ) ) , Module ( I i Double ) ( T ( I i 2 ) )
, Torsor ( T ( I i ( ℝ 2 ) ) ) ( I i ( ℝ 2 ) ) , Torsor ( T ( I i 2 ) ) ( I i 2 )
, Module ( I i Double ) ( T ( I i usedParams ) ) , Module ( I i Double ) ( T ( I i nbUsedParams ) )
, Torsor ( T ( I i usedParams ) ) ( I i usedParams ) , Torsor ( T ( I i nbUsedParams ) ) ( I i nbUsedParams )
, Module Double ( T usedParams ) , Module Double ( T ( I ℝ nbUsedParams ) )
, Representable Double usedParams , Torsor ( T ( ( I ℝ nbUsedParams ) ) ) ( I ℝ nbUsedParams )
, Torsor ( T usedParams ) usedParams , Representable Double ( ℝ nbUsedParams )
, Representable 𝕀 ( 𝕀ℝ nbUsedParams )
) )
=> ( I i ( ℝ 1 ) -> I i Double ) => ( I i 1 -> I i Double )
-> ( forall a. a -> I i a ) -> ( I ℝ 2 -> I i 2 )
-> ( ptData -> usedParams ) -> ( I ℝ nbUsedParams -> I i nbUsedParams )
-> ( ptData -> I ℝ nbUsedParams )
-> ptData -> ptData
-> Curve Open crvData ptData -> Curve Open crvData ptData
-> ( I i ( ℝ 1 ) `arr` I i ( ℝ 2 ), I i ( ℝ 1 ) `arr` I i usedParams ) -> ( I i 1 `arr` I i 2, I i 1 `arr` I i nbUsedParams )
pathAndUsedParams co toI ptParams sp0 crv = pathAndUsedParams co toI1 toI2 ptParams sp0 crv =
case crv of case crv of
LineTo { curveEnd = NextPoint sp1 } LineTo { curveEnd = NextPoint sp1 }
| let seg = Segment sp0 sp1 | let seg = Segment sp0 sp1
-> ( line @k @i @( ℝ 2 ) co ( fmap ( toI . coords ) seg ) -> ( line @k @i @2 co ( fmap ( toI1 . coords ) seg )
, line @k @i @usedParams co ( fmap ( toI . ptParams ) seg ) ) , line @k @i @nbUsedParams co ( fmap ( toI2 . ptParams ) seg ) )
Bezier2To { controlPoint = sp1, curveEnd = NextPoint sp2 } Bezier2To { controlPoint = sp1, curveEnd = NextPoint sp2 }
| let bez2 = Quadratic.Bezier sp0 sp1 sp2 | let bez2 = Quadratic.Bezier sp0 sp1 sp2
-> ( bezier2 @k @i @( ℝ 2 ) co ( fmap ( toI . coords ) bez2 ) -> ( bezier2 @k @i @2 co ( fmap ( toI1 . coords ) bez2 )
, bezier2 @k @i @usedParams co ( fmap ( toI . ptParams ) bez2 ) ) , bezier2 @k @i @nbUsedParams co ( fmap ( toI2 . ptParams ) bez2 ) )
Bezier3To { controlPoint1 = sp1, controlPoint2 = sp2, curveEnd = NextPoint sp3 } Bezier3To { controlPoint1 = sp1, controlPoint2 = sp2, curveEnd = NextPoint sp3 }
| let bez3 = Cubic.Bezier sp0 sp1 sp2 sp3 | let bez3 = Cubic.Bezier sp0 sp1 sp2 sp3
-> ( bezier3 @k @i @( ℝ 2 ) co ( fmap ( toI . coords ) bez3 ) -> ( bezier3 @k @i @2 co ( fmap ( toI1 . coords ) bez3 )
, bezier3 @k @i @usedParams co ( fmap ( toI . ptParams ) bez3 ) ) , bezier3 @k @i @nbUsedParams co ( fmap ( toI2 . ptParams ) bez3 ) )
{-# INLINEABLE pathAndUsedParams #-} {-# INLINEABLE pathAndUsedParams #-}
----------------------------------- -----------------------------------
@ -951,12 +955,12 @@ withTangent tgt_wanted spline@( Spline { splineStart } )
splineCurveFns :: forall k i splineCurveFns :: forall k i
. ( HasBézier k i . ( HasBézier k i
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , D k ( I i 1 ) ~ D k ( ℝ 1 )
, Module ( I i Double ) ( T ( I i ( ℝ 2 ) ) ) , Module ( I i Double ) ( T ( I i 2 ) )
, Torsor ( T ( I i ( ℝ 2 ) ) ) ( I i ( ℝ 2 ) ) ) , Torsor ( T ( I i 2 ) ) ( I i 2 ) )
=> ( I i ( ℝ 1 ) -> I i Double ) => ( I i 1 -> I i Double )
-> Spline Closed () ( I i ( ℝ 2 ) ) -> Spline Closed () ( I i 2 )
-> Seq ( C k ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) ) -> Seq ( C k ( I i 1 ) ( I i 2 ) )
splineCurveFns co spls splineCurveFns co spls
= runIdentity = runIdentity
. bifoldSpline . bifoldSpline
@ -965,16 +969,16 @@ splineCurveFns co spls
. adjustSplineType @Open . adjustSplineType @Open
$ spls $ spls
where where
curveFn :: I i ( ℝ 2 ) curveFn :: I i 2
-> Curve Open () ( I i ( ℝ 2 ) ) -> Curve Open () ( I i 2 )
-> C k ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) -> C k ( I i 1 ) ( I i 2 )
curveFn p0 = \case curveFn p0 = \case
LineTo { curveEnd = NextPoint p1 } LineTo { curveEnd = NextPoint p1 }
-> line @k @i @( ℝ 2 ) co $ Segment p0 p1 -> line @k @i @2 co $ Segment p0 p1
Bezier2To { controlPoint = p1, curveEnd = NextPoint p2 } Bezier2To { controlPoint = p1, curveEnd = NextPoint p2 }
-> bezier2 @k @i @( ℝ 2 ) co $ Quadratic.Bezier p0 p1 p2 -> bezier2 @k @i @2 co $ Quadratic.Bezier p0 p1 p2
Bezier3To { controlPoint1 = p1, controlPoint2 = p2, curveEnd = NextPoint p3 } Bezier3To { controlPoint1 = p1, controlPoint2 = p2, curveEnd = NextPoint p3 }
-> bezier3 @k @i @( ℝ 2 ) co $ Cubic.Bezier p0 p1 p2 p3 -> bezier3 @k @i @2 co $ Cubic.Bezier p0 p1 p2 p3
newtype ZipSeq a = ZipSeq { getZipSeq :: Seq a } newtype ZipSeq a = ZipSeq { getZipSeq :: Seq a }
deriving stock Functor deriving stock Functor
@ -983,99 +987,102 @@ instance Applicative ZipSeq where
liftA2 f ( ZipSeq xs ) ( ZipSeq ys ) = ZipSeq ( Seq.zipWith f xs ys ) liftA2 f ( ZipSeq xs ) ( ZipSeq ys ) = ZipSeq ( Seq.zipWith f xs ys )
{-# INLINE liftA2 #-} {-# INLINE liftA2 #-}
brushStrokeData :: forall k brushParams i arr brushStrokeData :: forall {kd} (k :: Nat) (nbBrushParams :: Nat) (i :: kd) arr
. ( arr ~ C k . ( arr ~ C k
, HasBézier k i, HasEnvelopeEquation k , HasBézier k i, HasEnvelopeEquation k
, Differentiable k i brushParams , Differentiable k i nbBrushParams
, HasChainRule ( I i Double ) k ( I i ( ℝ 1 ) ) , HasChainRule ( I i Double ) k ( I i 1 )
, Applicative ( D k ( ℝ 1 ) ) , Applicative ( D k ( ℝ 1 ) )
, D ( k - 2 ) ( I i ( ℝ 2 ) ) ~ D ( k - 2 ) ( ℝ 2 ) , D ( k - 2 ) ( I i 2 ) ~ D ( k - 2 ) ( ℝ 2 )
, D ( k - 1 ) ( I i ( ℝ 2 ) ) ~ D ( k - 1 ) ( ℝ 2 ) , D ( k - 1 ) ( I i 2 ) ~ D ( k - 1 ) ( ℝ 2 )
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , D k ( I i 1 ) ~ D k ( ℝ 1 )
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , D k ( I i 1 ) ~ D k ( ℝ 1 )
, D k ( I i ( ℝ 2 ) ) ~ D k ( ℝ 2 ) , D k ( I i 2 ) ~ D k ( ℝ 2 )
, Transcendental ( I i Double ) , Transcendental ( I i Double )
, Module ( I i Double ) ( T ( I i ( ℝ 1 ) ) ) , Module ( I i Double ) ( T ( I i 1 ) )
, Cross ( I i Double ) ( T ( I i ( ℝ 2 ) ) ) , Cross ( I i Double ) ( T ( I i 2 ) )
, Torsor ( T ( I i ( ℝ 2 ) ) ) ( I i ( ℝ 2 ) ) , Torsor ( T ( I i 2 ) ) ( I i 2 )
, Show brushParams , Show ( ℝ nbBrushParams )
, Representable ( I i Double ) ( I i ( ℝ 2 ) ), RepDim ( I i ( ℝ 2 ) ) ~ 2 , Representable ( I i Double ) ( I i 2 ), RepDim ( I i 2 ) ~ 2
) )
=> ( I i Double -> I i ( ℝ 1 ) ) => ( I i Double -> I i 1 )
-> ( I i ( ℝ 1 ) -> I i Double ) -> ( I i 1 -> I i Double )
-> ( I i ( ℝ 1 ) `arr` I i ( ℝ 2 ) ) -> ( I i 1 `arr` I i 2 )
-- ^ path -- ^ path
-> ( I i ( ℝ 1 ) `arr` I i brushParams ) -> ( I i 1 `arr` I i nbBrushParams )
-- ^ brush parameters -- ^ brush parameters
-> ( I i brushParams `arr` Spline Closed () ( I i ( ℝ 2 ) ) ) -> ( I i nbBrushParams `arr` Spline Closed () ( I i 2 ) )
-- ^ brush from parameters -- ^ brush from parameters
-> ( Maybe ( I i brushParams -> I i Double ) ) -> ( Maybe ( I i nbBrushParams -> I i Double ) )
-- ^ rotation parameter -- ^ rotation parameter
-> ( I i ( ℝ 1 ) -> Seq ( I i ( ℝ 1 ) -> StrokeDatum k i ) ) -> ( I i 1 -> Seq ( I i 1 -> StrokeDatum k i ) )
brushStrokeData co1 co2 path params brush mbBrushRotation = brushStrokeData co1 co2 path params brush mbBrushRotation =
\ t -> \ t ->
let let
dpath_t :: D k ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) dpath_t :: D k ( I i 1 ) ( I i 2 )
!dpath_t = runD path t !dpath_t = runD path t
dparams_t :: D k ( I i ( ℝ 1 ) ) ( I i brushParams ) dparams_t :: D k ( I i 1 ) ( I i nbBrushParams )
!dparams_t = runD params t !dparams_t = runD params t
dbrush_params :: D k ( I i brushParams ) ( Spline Closed () ( I i ( ℝ 2 ) ) ) dbrush_params :: D k ( I i nbBrushParams ) ( Spline Closed () ( I i 2 ) )
!dbrush_params = runD brush $ value @( I i Double ) @k @( I i ( ℝ 1 ) ) dparams_t !dbrush_params = runD brush $ value @( I i Double ) @k @( I i 1 ) dparams_t
splines :: Seq ( D k ( I i brushParams ) ( I i ( ℝ 1 ) `arr` I i ( ℝ 2 ) ) ) splines :: Seq ( D k ( I i nbBrushParams ) ( I i 1 `arr` I i 2 ) )
!splines = getZipSeq $ traverse ( ZipSeq . splineCurveFns @k @i co2 ) dbrush_params !splines = getZipSeq $ traverse ( ZipSeq . splineCurveFns @k @i co2 ) dbrush_params
dbrushes_t :: Seq ( I i ( ℝ 1 ) -> D k ( I i ( ℝ 2 ) ) ( I i ( ℝ 2 ) ) ) dbrushes_t :: Seq ( I i 1 -> D k ( I i 2 ) ( I i 2 ) )
!dbrushes_t = force $ fmap ( uncurryD @k . chain @( I i Double ) @k dparams_t ) splines !dbrushes_t = force $ fmap ( uncurryD @k . chain @( I i Double ) @k dparams_t ) splines
-- This is the crucial use of the chain rule. -- This is the crucial use of the chain rule.
in fmap ( mkStrokeDatum dpath_t dparams_t ) dbrushes_t in fmap ( mkStrokeDatum dpath_t dparams_t ) dbrushes_t
where where
mkStrokeDatum :: D k ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) mkStrokeDatum :: D k ( I i 1 ) ( I i 2 )
-> D k ( I i ( ℝ 1 ) ) ( I i brushParams ) -> D k ( I i 1 ) ( I i nbBrushParams )
-> ( I i ( ℝ 1 ) -> D k ( I i ( ℝ 2 ) ) ( I i ( ℝ 2 ) ) ) -> ( I i 1 -> D k ( I i 2 ) ( I i 2 ) )
-> ( I i ( ℝ 1 ) -> StrokeDatum k i ) -> ( I i 1 -> StrokeDatum k i )
mkStrokeDatum dpath_t dparams_t dbrush_t s = mkStrokeDatum dpath_t dparams_t dbrush_t s =
let dbrush_t_s = dbrush_t s let dbrush_t_s = dbrush_t s
mbRotation = mbBrushRotation <&> \ getTheta -> fmap getTheta dparams_t mbRotation = mbBrushRotation <&> \ getTheta -> fmap getTheta dparams_t
in envelopeEquation @k @i Proxy co1 dpath_t dbrush_t_s mbRotation in envelopeEquation @k @i Proxy co1 dpath_t dbrush_t_s mbRotation
{-# INLINEABLE brushStrokeData #-} {-# INLINEABLE brushStrokeData #-}
{-
{-# SPECIALISE brushStrokeData {-# SPECIALISE brushStrokeData
:: ( I 𝕀 Double -> I 𝕀 ( ℝ 1 ) ) :: ( 𝕀 -> ( 𝕀ℝ 1 ) )
-> ( I 𝕀 ( ℝ 1 ) -> I 𝕀 Double ) -> ( 𝕀ℝ 1 -> 𝕀 )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 2 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 1 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 1 ) )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( Spline Closed () ( I 𝕀 ( ℝ 2 ) ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( Spline Closed () ( 𝕀ℝ 2 ) ) )
-> ( Maybe ( I 𝕀 ( ℝ 1 ) -> I 𝕀 Double ) ) -> ( Maybe ( 𝕀ℝ 1 -> 𝕀 ) )
-> ( I 𝕀 ( ℝ 1 ) -> Seq ( I 𝕀 ( ℝ 1 ) -> StrokeDatum 3 𝕀 ) ) -> ( 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
{-# SPECIALISE brushStrokeData {-# SPECIALISE brushStrokeData
:: ( I 𝕀 Double -> I 𝕀 ( ℝ 1 ) ) :: ( 𝕀 -> ( 𝕀ℝ 1 ) )
-> ( I 𝕀 ( ℝ 1 ) -> I 𝕀 Double ) -> ( 𝕀ℝ 1 -> 𝕀 )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 2 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 2 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) )
-> ( C 3 ( I 𝕀 ( ℝ 2 ) ) ( Spline Closed () ( I 𝕀 ( ℝ 2 ) ) ) ) -> ( C 3 ( 𝕀ℝ 2 ) ( Spline Closed () ( 𝕀ℝ 2 ) ) )
-> ( Maybe ( I 𝕀 ( ℝ 2 ) -> I 𝕀 Double ) ) -> ( Maybe ( 𝕀ℝ 2 -> 𝕀) )
-> ( I 𝕀 ( ℝ 1 ) -> Seq ( I 𝕀 ( ℝ 1 ) -> StrokeDatum 3 𝕀 ) ) -> ( 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
{-# SPECIALISE brushStrokeData {-# SPECIALISE brushStrokeData
:: ( I 𝕀 Double -> I 𝕀 ( ℝ 1 ) ) :: ( 𝕀 -> ( 𝕀ℝ 1 ) )
-> ( I 𝕀 ( ℝ 1 ) -> I 𝕀 Double ) -> ( 𝕀ℝ 1 -> 𝕀 )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 2 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 3 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 3 ) )
-> ( C 3 ( I 𝕀 ( ℝ 3 ) ) ( Spline Closed () ( I 𝕀 ( ℝ 2 ) ) ) ) -> ( C 3 ( 𝕀ℝ 3 ) ( Spline Closed () ( 𝕀ℝ 2 ) ) )
-> ( Maybe ( I 𝕀 ( ℝ 3 ) -> I 𝕀 Double ) ) -> ( Maybe ( 𝕀ℝ 3 -> 𝕀 ) )
-> ( I 𝕀 ( ℝ 1 ) -> Seq ( I 𝕀 ( ℝ 1 ) -> StrokeDatum 3 𝕀 ) ) -> ( 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
{-# SPECIALISE brushStrokeData {-# SPECIALISE brushStrokeData
:: ( I 𝕀 Double -> I 𝕀 ( ℝ 1 ) ) :: ( 𝕀 -> ( 𝕀ℝ 1 ) )
-> ( I 𝕀 ( ℝ 1 ) -> I 𝕀 Double ) -> ( 𝕀ℝ 1 -> 𝕀 )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 2 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 2 ) )
-> ( C 3 ( I 𝕀 ( ℝ 1 ) ) ( I 𝕀 ( ℝ 4 ) ) ) -> ( C 3 ( 𝕀ℝ 1 ) ( 𝕀ℝ 4 ) )
-> ( C 3 ( I 𝕀 ( ℝ 4 ) ) ( Spline Closed () ( I 𝕀 ( ℝ 2 ) ) ) ) -> ( C 3 ( 𝕀ℝ 4 ) ( Spline Closed () ( 𝕀ℝ 2 ) ) )
-> ( Maybe ( I 𝕀 ( ℝ 4 ) -> I 𝕀 Double ) ) -> ( Maybe ( 𝕀ℝ 4 -> 𝕀 ) )
-> ( I 𝕀 ( ℝ 1 ) -> Seq ( I 𝕀 ( ℝ 1 ) -> StrokeDatum 3 𝕀 ) ) -> ( 𝕀ℝ 1 -> Seq ( 𝕀ℝ 1 -> StrokeDatum 3 𝕀 ) )
#-} #-}
-}
-- TODO: these specialisations fire in the benchmarking code because -- TODO: these specialisations fire in the benchmarking code because
-- we instantiate brushParams with ( ℝ nbBrushParams ), but they won't fire -- we instantiate brushParams with ( ℝ nbBrushParams ), but they won't fire
-- in the main app code because we are using types such as "Record EllipseBrushFields". -- in the main app code because we are using types such as "Record EllipseBrushFields".
@ -1097,7 +1104,7 @@ solveEnvelopeEquations :: RootSolvingAlgorithm
-> ℝ 2 -> ℝ 2
-> T ( ℝ 2 ) -> T ( ℝ 2 )
-> ( Offset, Offset ) -> ( Offset, Offset )
-> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ )
-> ( ( ℝ 2, T ( ℝ 2 ) ), ( ℝ 2, T ( ℝ 2 ) ) ) -> ( ( ℝ 2, T ( ℝ 2 ) ), ( ℝ 2, T ( ℝ 2 ) ) )
solveEnvelopeEquations rootAlgo ( ℝ1 _t ) path_t path'_t ( fwdOffset, bwdOffset ) strokeData solveEnvelopeEquations rootAlgo ( ℝ1 _t ) path_t path'_t ( fwdOffset, bwdOffset ) strokeData
= ( fwdSol, ( bwdPt, -1 *^ bwdTgt ) ) = ( fwdSol, ( bwdPt, -1 *^ bwdTgt ) )
@ -1121,7 +1128,7 @@ solveEnvelopeEquations rootAlgo ( ℝ1 _t ) path_t path'_t ( fwdOffset, bwdOffse
| otherwise | otherwise
-> ( off • path_t, path'_t ) -> ( off • path_t, path'_t )
sol :: String -> Seq ( ℝ 1 -> StrokeDatum 2 () ) -> Double -> ( Bool, ℝ 2, T ( ℝ 2 ) ) sol :: String -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ ) -> Double -> ( Bool, ℝ 2, T ( ℝ 2 ) )
sol desc f is0 = sol desc f is0 =
let ( solRes, _solSteps ) = runSolveMethod ( eqn f ) is0 let ( solRes, _solSteps ) = runSolveMethod ( eqn f ) is0
( good, is ) = ( good, is ) =
@ -1141,7 +1148,7 @@ solveEnvelopeEquations rootAlgo ( ℝ1 _t ) path_t path'_t ( fwdOffset, bwdOffse
NewtonRaphson { maxIters, precision } -> NewtonRaphson { maxIters, precision } ->
newtonRaphson maxIters precision domain newtonRaphson maxIters precision domain
finish :: Seq ( ℝ 1 -> StrokeDatum 2 () ) -> Double -> ( Double, ℝ 2, T ( ℝ 2 ) ) finish :: Seq ( ℝ 1 -> StrokeDatum 2 ℝ ) -> Double -> ( Double, ℝ 2, T ( ℝ 2 ) )
finish fs is = finish fs is =
let (i, s) = fromDomain is in let (i, s) = fromDomain is in
case evalStrokeDatum fs is of -- TODO: a bit redundant to have to compute this again... case evalStrokeDatum fs is of -- TODO: a bit redundant to have to compute this again...
@ -1174,12 +1181,12 @@ solveEnvelopeEquations rootAlgo ( ℝ1 _t ) path_t path'_t ( fwdOffset, bwdOffse
-- The sign of this quantity determines which side of the envelope -- The sign of this quantity determines which side of the envelope
-- we are on. -- we are on.
evalStrokeDatum :: Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( Double -> StrokeDatum 2 () ) evalStrokeDatum :: Seq ( ℝ 1 -> StrokeDatum 2 ℝ ) -> ( Double -> StrokeDatum 2 ℝ )
evalStrokeDatum fs is = evalStrokeDatum fs is =
let (i, s) = fromDomain is let (i, s) = fromDomain is
in ( fs `Seq.index` i ) ( ℝ1 $ max 1e-6 $ min (1 - 1e-6) $ s ) in ( fs `Seq.index` i ) ( ℝ1 $ max 1e-6 $ min (1 - 1e-6) $ s )
eqn :: Seq ( ℝ 1 -> StrokeDatum 2 () ) -> ( Double -> (# Double, Double #) ) eqn :: Seq ( ℝ 1 -> StrokeDatum 2 ℝ ) -> ( Double -> (# Double, Double #) )
eqn fs is = eqn fs is =
case evalStrokeDatum fs is of case evalStrokeDatum fs is of
StrokeDatum { ee = D12 ee _ ee_s } -> coerce (# ee, ee_s #) StrokeDatum { ee = D12 ee _ ee_s } -> coerce (# ee, ee_s #)
@ -1202,7 +1209,7 @@ solveEnvelopeEquations rootAlgo ( ℝ1 _t ) path_t path'_t ( fwdOffset, bwdOffse
-- --
-- TODO: use Newton's method starting at the midpoint of the box, -- TODO: use Newton's method starting at the midpoint of the box,
-- instead of just taking the midpoint of the box. -- instead of just taking the midpoint of the box.
cuspCoords :: ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 () ) ) cuspCoords :: ( ℝ 1 -> Seq ( ℝ 1 -> StrokeDatum 2 ℝ ) )
-> ( Int, Box N ) -> ( Int, Box N )
-> Cusp -> Cusp
cuspCoords eqs ( i, box ) cuspCoords eqs ( i, box )
@ -1231,8 +1238,8 @@ findCusps
findCusps opts boxStrokeData = findCusps opts boxStrokeData =
findCuspsIn opts boxStrokeData $ findCuspsIn opts boxStrokeData $
IntMap.fromList IntMap.fromList
[ ( i, [ 𝕀 ( ℝ2 zero zero ) ( ℝ2 one one ) ] ) --[ 𝕀 ( ℝ3 zero zero -1e6 ) ( ℝ3 one one 1e6 ) ] ) [ ( i, [ 𝕀ℝ2 ( 𝕀 zero one ) ( 𝕀 zero one ) ] )
| i <- [ 0 .. length ( boxStrokeData ( 𝕀 ( ℝ1 zero ) ( ℝ1 one ) ) ) - 1 ] | i <- [ 0 .. length ( boxStrokeData ( 𝕀ℝ1 ( 𝕀 zero one ) ) ) - 1 ]
] ]
where where
zero, one :: Double zero, one :: Double
@ -1251,23 +1258,20 @@ findCuspsIn
findCuspsIn opts boxStrokeData initBoxes = findCuspsIn opts boxStrokeData initBoxes =
IntMap.mapWithKey ( \ i -> foldMap ( isolateRootsIn opts ( eqnPiece i ) ) ) initBoxes IntMap.mapWithKey ( \ i -> foldMap ( isolateRootsIn opts ( eqnPiece i ) ) ) initBoxes
where where
eqnPiece i ( 𝕀 ( ℝ2 t_lo s_lo ) ( ℝ2 t_hi s_hi ) ) = eqnPiece i ( 𝕀ℝ2 t s ) =
let t = 𝕀 ( ℝ1 t_lo ) ( ℝ1 t_hi ) let StrokeDatum
s = 𝕀 ( ℝ1 s_lo ) ( ℝ1 s_hi )
-- This conversion is quite painful, but hey...
StrokeDatum
{ ee = { ee =
D22 { _D22_v = 𝕀 ( ℝ1 ee_lo ) ( ℝ1 ee_hi ) D22 { _D22_v = 𝕀ℝ1 ee
, _D22_dx = T ( 𝕀 ( ℝ1 ee_t_lo ) ( ℝ1 ee_t_hi ) ) , _D22_dx = T ( 𝕀ℝ1 ee_t )
, _D22_dy = T ( 𝕀 ( ℝ1 ee_s_lo ) ( ℝ1 ee_s_hi ) ) } , _D22_dy = T ( 𝕀ℝ1 ee_s ) }
, 𝛿E𝛿sdcdt = , 𝛿E𝛿sdcdt =
D12 { _D12_v = T ( 𝕀 ( ℝ2 f_lo g_lo ) ( ℝ2 f_hi g_hi ) ) D12 { _D12_v = T ( 𝕀ℝ2 f g )
, _D12_dx = T ( T ( 𝕀 ( ℝ2 f_t_lo g_t_lo ) ( ℝ2 f_t_hi g_t_hi ) ) ) , _D12_dx = T ( T ( 𝕀ℝ2 f_t g_t ) )
, _D12_dy = T ( T ( 𝕀 ( ℝ2 f_s_lo g_s_lo ) ( ℝ2 f_s_hi g_s_hi ) ) ) } , _D12_dy = T ( T ( 𝕀ℝ2 f_s g_s ) ) }
} = ( boxStrokeData t `Seq.index` i ) s } = ( boxStrokeData ( 𝕀ℝ1 t ) `Seq.index` i ) ( 𝕀ℝ1 s )
in D12 ( 𝕀 ( ℝ3 ee_lo f_lo g_lo ) ( ℝ3 ee_hi f_hi g_hi ) ) in D12 ( 𝕀ℝ3 ee f g )
( T $ 𝕀 ( ℝ3 ee_t_lo f_t_lo g_t_lo ) ( ℝ3 ee_t_hi f_t_hi g_t_hi ) ) ( T $ 𝕀ℝ3 ee_t f_t g_t )
( T $ 𝕀 ( ℝ3 ee_s_lo f_s_lo g_s_lo ) ( ℝ3 ee_s_hi f_s_hi g_s_hi ) ) ( T $ 𝕀ℝ3 ee_s f_s g_s )
{- {-
findCuspsIn findCuspsIn
@ -1344,14 +1348,14 @@ findCuspsIn opts boxStrokeData initBoxes =
( T $ 𝕀 ( ℝ3 f1_s_lo f2_s_lo f3_s_lo ) ( ℝ3 f1_s_hi f2_s_hi f3_s_hi ) ) ( T $ 𝕀 ( ℝ3 f1_s_lo f2_s_lo f3_s_lo ) ( ℝ3 f1_s_hi f2_s_hi f3_s_hi ) )
( T $ 𝕀 ( ℝ3 f1_λ_lo f2_λ_lo f3_λ_lo ) ( ℝ3 f1_λ_hi f2_λ_hi f3_λ_hi ) ) ( T $ 𝕀 ( ℝ3 f1_λ_lo f2_λ_lo f3_λ_lo ) ( ℝ3 f1_λ_hi f2_λ_hi f3_λ_hi ) )
intersectMany :: [𝕀 Double] -> [𝕀 Double] -> [𝕀 Double] intersectMany :: [𝕀] -> [𝕀] -> [𝕀]
intersectMany _ [] = [] intersectMany _ [] = []
intersectMany is (j : js) = intersectOne is j ++ intersectMany is js intersectMany is (j : js) = intersectOne is j ++ intersectMany is js
intersectOne :: [ 𝕀 Double ] -> 𝕀 Double -> [ 𝕀 Double ] intersectOne :: [ 𝕀 ] -> 𝕀 -> [ 𝕀 ]
intersectOne is i = concatMap ( intersect i ) is intersectOne is i = concatMap ( intersect i ) is
intersect :: 𝕀 Double -> 𝕀 Double -> [ 𝕀 Double ] intersect :: 𝕀 -> 𝕀 -> [ 𝕀 ]
intersect ( 𝕀 lo1 hi1 ) ( 𝕀 lo2 hi2 ) intersect ( 𝕀 lo1 hi1 ) ( 𝕀 lo2 hi2 )
| lo > hi | lo > hi
= [ ] = [ ]

102
brush-strokes/src/lib/Math/Bezier/Stroke/EnvelopeEquation.hs
View file

@ -45,35 +45,35 @@ type StrokeDatum :: Nat -> k -> Type
data StrokeDatum k i data StrokeDatum k i
= StrokeDatum = StrokeDatum
{ -- | Path \( p(t) \). { -- | Path \( p(t) \).
dpath :: D k ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) dpath :: D k ( I i 1 ) ( I i 2 )
-- | Brush shape \( b(t, s) \). -- | Brush shape \( b(t, s) \).
, dbrush :: D k ( I i ( ℝ 2 ) ) ( I i ( ℝ 2 ) ) , dbrush :: D k ( I i 2 ) ( I i 2 )
-- | (Optional) rotation angle \( \theta(t) \). -- | (Optional) rotation angle \( \theta(t) \).
, mbRotation :: Maybe ( D k ( I i ( ℝ 1 ) ) ( I i Double ) ) , mbRotation :: Maybe ( D k ( I i 1 ) ( I i Double ) )
-- Everything below is computed in terms of the first three fields. -- Everything below is computed in terms of the first three fields.
-- | Stroke shape \( c(t,s) = p(t) + R(\theta(t)) b(t,s) \). -- | Stroke shape \( c(t,s) = p(t) + R(\theta(t)) b(t,s) \).
, stroke :: I i ( ℝ 2 ) , stroke :: I i 2
-- | \( u(t,s) = R(-\theta(t)) \frac{\partial c}{\partial t} \), -- | \( u(t,s) = R(-\theta(t)) \frac{\partial c}{\partial t} \),
-- \( v(t,s) = R(-\theta(t)) \frac{\partial c}{\partial s} \) -- \( v(t,s) = R(-\theta(t)) \frac{\partial c}{\partial s} \)
, du, dv :: D ( k - 1 ) ( I i ( ℝ 2 ) ) ( I i ( ℝ 2 ) ) , du, dv :: D ( k - 1 ) ( I i 2 ) ( I i 2 )
-- | Envelope function -- | Envelope function
-- --
-- \[ E(t_0,s_0) = \left ( \frac{\partial c}{\partial t} \times \frac{\partial c}{\partial s} \right )_{(t_0,s_0)}. \] -- \[ E(t_0,s_0) = \left ( \frac{\partial c}{\partial t} \times \frac{\partial c}{\partial s} \right )_{(t_0,s_0)}. \]
, ee :: D ( k - 1 ) ( I i ( ℝ 2 ) ) ( I i ( ℝ 1 ) ) , ee :: D ( k - 1 ) ( I i 2 ) ( I i 1 )
-- \[ \frac{\partial E}{\partial s} \frac{\mathrm{d} c}{\mathrm{d} t}, \] -- \[ \frac{\partial E}{\partial s} \frac{\mathrm{d} c}{\mathrm{d} t}, \]
-- --
-- where \( \frac{\mathrm{d} c}{\mathrm{d} t} \) -- where \( \frac{\mathrm{d} c}{\mathrm{d} t} \)
-- --
-- denotes a total derivative. -- denotes a total derivative.
, 𝛿E𝛿sdcdt :: D ( k - 2 ) ( I i ( ℝ 2 ) ) ( T ( I i ( ℝ 2 ) ) ) , 𝛿E𝛿sdcdt :: D ( k - 2 ) ( I i 2 ) ( T ( I i 2 ) )
} }
deriving stock instance Show ( StrokeDatum 2 () ) deriving stock instance Show ( StrokeDatum 2 ℝ )
deriving stock instance Show ( StrokeDatum 3 𝕀 ) deriving stock instance Show ( StrokeDatum 3 𝕀 )
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
@ -82,33 +82,35 @@ type HasBézier :: forall {t}. Nat -> t -> Constraint
class HasBézier k i where class HasBézier k i where
-- | Linear interpolation, as a differentiable function. -- | Linear interpolation, as a differentiable function.
line :: forall b line :: forall ( n :: Nat )
. ( Module Double ( T b ), Torsor ( T b ) b . ( Module Double ( T ( ℝ n ) ), Torsor ( T ( ℝ n ) ) ( ℝ n )
, Module ( I i Double ) ( T (I i b ) ), Torsor ( T ( I i b ) ) ( I i b ) , Module ( I i Double ) ( T ( I i n ) ), Torsor ( T ( I i n ) ) ( I i n )
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , D k ( I i 1 ) ~ D k ( ℝ 1 )
) )
=> ( I i ( ℝ 1 ) -> I i Double ) => ( I i 1 -> I i Double )
-> Segment ( I i b ) -> C k ( I i ( ℝ 1 ) ) ( I i b ) -> Segment ( I i n ) -> C k ( I i 1 ) ( I i n )
-- | A quadratic Bézier curve, as a differentiable function. -- | A quadratic Bézier curve, as a differentiable function.
bezier2 :: forall b bezier2 :: forall ( n :: Nat )
. ( Module Double ( T b ), Torsor ( T b ) b . ( Module Double ( T ( ℝ n ) ), Torsor ( T ( ℝ n ) ) ( ℝ n )
, Module ( I i Double ) ( T (I i b ) ), Torsor ( T ( I i b ) ) ( I i b ) , Module ( I i Double ) ( T ( I i n ) ), Torsor ( T ( I i n ) ) ( I i n )
, Representable Double b , Representable Double ( ℝ n )
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , Representable 𝕀 ( 𝕀ℝ n )
, D k ( I i 1 ) ~ D k ( ℝ 1 )
) )
=> ( I i ( ℝ 1 ) -> I i Double ) => ( I i 1 -> I i Double )
-> Quadratic.Bezier ( I i b ) -> C k ( I i ( ℝ 1 ) ) ( I i b ) -> Quadratic.Bezier ( I i n ) -> C k ( I i 1 ) ( I i n )
-- | A cubic Bézier curve, as a differentiable function. -- | A cubic Bézier curve, as a differentiable function.
bezier3 :: forall b bezier3 :: forall ( n :: Nat )
. ( Module Double ( T b ), Torsor ( T b ) b . ( Module Double ( T ( ℝ n ) ), Torsor ( T ( ℝ n ) ) ( ℝ n )
, Module ( I i Double ) ( T (I i b ) ), Torsor ( T ( I i b ) ) ( I i b ) , Module ( I i Double ) ( T ( I i n ) ), Torsor ( T ( I i n ) ) ( I i n )
, Representable Double b , Representable Double ( ℝ n )
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , Representable 𝕀 ( 𝕀ℝ n )
, D k ( I i 1 ) ~ D k ( ℝ 1 )
) )
=> ( I i ( ℝ 1 ) -> I i Double ) => ( I i 1 -> I i Double )
-> Cubic.Bezier ( I i b ) -> C k ( I i ( ℝ 1 ) ) ( I i b ) -> Cubic.Bezier ( I i n ) -> C k ( I i 1 ) ( I i n )
type HasEnvelopeEquation :: Nat -> Constraint type HasEnvelopeEquation :: Nat -> Constraint
class HasEnvelopeEquation k where class HasEnvelopeEquation k where
@ -128,24 +130,24 @@ class HasEnvelopeEquation k where
-- --
-- denotes a total derivative. -- denotes a total derivative.
envelopeEquation :: forall i envelopeEquation :: forall i
. ( D ( k - 2 ) ( I i ( ℝ 2 ) ) ~ D ( k - 2 ) ( ℝ 2 ) . ( D ( k - 2 ) ( I i 2 ) ~ D ( k - 2 ) ( ℝ 2 )
, D ( k - 1 ) ( I i ( ℝ 2 ) ) ~ D ( k - 1 ) ( ℝ 2 ) , D ( k - 1 ) ( I i 2 ) ~ D ( k - 1 ) ( ℝ 2 )
, D k ( I i ( ℝ 2 ) ) ~ D k ( ℝ 2 ) , D k ( I i 2 ) ~ D k ( ℝ 2 )
, D k ( I i ( ℝ 1 ) ) ~ D k ( ℝ 1 ) , D k ( I i 1 ) ~ D k ( ℝ 1 )
, Module ( I i Double ) ( T ( I i ( ℝ 1 ) ) ) , Module ( I i Double ) ( T ( I i 1 ) )
, Cross ( I i Double ) ( T ( I i ( ℝ 2 ) ) ) , Cross ( I i Double ) ( T ( I i 2 ) )
, Transcendental ( I i Double ) , Transcendental ( I i Double )
, Representable ( I i Double ) ( I i ( ℝ 2 ) ) , Representable ( I i Double ) ( I i 2 )
, RepDim ( I i ( ℝ 2 ) ) ~ 2 , RepDim ( I i 2 ) ~ 2
) )
=> Proxy i => Proxy i
-> ( I i Double -> I i ( ℝ 1 ) ) -> ( I i Double -> I i 1 )
-> D k ( I i ( ℝ 1 ) ) ( I i ( ℝ 2 ) ) -> D k ( I i 1 ) ( I i 2 )
-> D k ( I i ( ℝ 2 ) ) ( I i ( ℝ 2 ) ) -> D k ( I i 2 ) ( I i 2 )
-> Maybe ( D k ( I i ( ℝ 1 ) ) ( I i Double ) ) -> Maybe ( D k ( I i 1 ) ( I i Double ) )
-> StrokeDatum k i -> StrokeDatum k i
instance HasBézier 2 () where instance HasBézier 2 ℝ where
line co ( Segment a b :: Segment b ) = line co ( Segment a b :: Segment b ) =
D \ ( co -> t ) -> D \ ( co -> t ) ->
D21 ( lerp @( T b ) t a b ) D21 ( lerp @( T b ) t a b )
@ -217,14 +219,14 @@ instance HasEnvelopeEquation 2 where
-- = ( R(-θ(t)) ∂c/∂t ) × ( R(-θ(t)) ∂c/ds ) -- = ( R(-θ(t)) ∂c/∂t ) × ( R(-θ(t)) ∂c/ds )
-- = ( R(-θ(t)) p'(t) + θ'(t) S b(t,s) + ∂b/∂t ) × ∂b/ds -- = ( R(-θ(t)) p'(t) + θ'(t) S b(t,s) + ∂b/∂t ) × ∂b/ds
-- --
let rot, rot' :: T ( I i ( ℝ 2 ) ) -> T ( I i ( ℝ 2 ) ) let rot, rot' :: T ( I i 2 ) -> T ( I i 2 )
cosθ = cos θ cosθ = cos θ
sinθ = sin θ sinθ = sin θ
-- rot = R(-θ), rot' = R'(-θ) -- rot = R(-θ), rot' = R'(-θ)
-- NB: rot' is not the derivative of f(θ) = R(-θ) -- NB: rot' is not the derivative of f(θ) = R(-θ)
rot = rotate cosθ -sinθ rot = rotate cosθ -sinθ
rot' = rotate sinθ cosθ rot' = rotate sinθ cosθ
swap :: T ( I i ( ℝ 2 ) ) -> T ( I i ( ℝ 2 ) ) swap :: T ( I i 2 ) -> T ( I i 2 )
swap ( T xy ) = swap ( T xy ) =
let x = xy `index` Fin 1 let x = xy `index` Fin 1
y = xy `index` Fin 2 y = xy `index` Fin 2
@ -232,7 +234,7 @@ instance HasEnvelopeEquation 2 where
Fin 1 -> -y Fin 1 -> -y
_ -> x _ -> x
u, v, u_t, u_s, v_t, v_s :: T ( I i ( ℝ 2 ) ) u, v, u_t, u_s, v_t, v_s :: T ( I i 2 )
u = rot p_t ^+^ θ_t *^ swap b ^+^ b_t u = rot p_t ^+^ θ_t *^ swap b ^+^ b_t
v = b_s v = b_s
u_t = ( -θ_t *^ rot' p_t u_t = ( -θ_t *^ rot' p_t
@ -253,7 +255,7 @@ instance HasEnvelopeEquation 2 where
) )
{-# INLINEABLE envelopeEquation #-} {-# INLINEABLE envelopeEquation #-}
instance HasBézier 3 () where instance HasBézier 3 ℝ where
line co ( Segment a b :: Segment b ) = line co ( Segment a b :: Segment b ) =
D \ ( co -> t ) -> D \ ( co -> t ) ->
@ -347,7 +349,7 @@ instance HasEnvelopeEquation 3 where
-- = ( R(-θ(t)) ∂c/∂t ) × ( R(-θ(t)) ∂c/ds ) -- = ( R(-θ(t)) ∂c/∂t ) × ( R(-θ(t)) ∂c/ds )
-- = ( R(-θ(t)) p'(t) + θ'(t) S b(t,s) + ∂b/∂t ) × ∂b/ds -- = ( R(-θ(t)) p'(t) + θ'(t) S b(t,s) + ∂b/∂t ) × ∂b/ds
-- --
let rot, rot', rot'' :: T ( I i ( ℝ 2 ) ) -> T ( I i ( ℝ 2 ) ) let rot, rot', rot'' :: T ( I i 2 ) -> T ( I i 2 )
cosθ = cos θ cosθ = cos θ
sinθ = sin θ sinθ = sin θ
-- rot = R(-θ), rot' = R'(-θ), rot'' = R''(-θ) -- rot = R(-θ), rot' = R'(-θ), rot'' = R''(-θ)
@ -355,7 +357,7 @@ instance HasEnvelopeEquation 3 where
rot = rotate cosθ -sinθ rot = rotate cosθ -sinθ
rot' = rotate sinθ cosθ rot' = rotate sinθ cosθ
rot'' z = -1 *^ rot z rot'' z = -1 *^ rot z
swap :: T ( I i ( ℝ 2 ) ) -> T ( I i ( ℝ 2 ) ) swap :: T ( I i 2 ) -> T ( I i 2 )
swap ( T xy ) = swap ( T xy ) =
let x = xy `index` Fin 1 let x = xy `index` Fin 1
y = xy `index` Fin 2 y = xy `index` Fin 2
@ -363,7 +365,7 @@ instance HasEnvelopeEquation 3 where
Fin 1 -> -y Fin 1 -> -y
_ -> x _ -> x
u, v, u_t, u_s, u_tt, u_ts, u_ss, v_t, v_s, v_tt, v_ts, v_ss :: T ( I i ( ℝ 2 ) ) u, v, u_t, u_s, u_tt, u_ts, u_ss, v_t, v_s, v_tt, v_ts, v_ss :: T ( I i 2 )
u = rot p_t ^+^ θ_t *^ swap b ^+^ b_t u = rot p_t ^+^ θ_t *^ swap b ^+^ b_t
v = b_s v = b_s
@ -458,7 +460,7 @@ with respect to t and root-finding.
-- | Evaluate a cubic Bézier curve, when both the coefficients and the -- | Evaluate a cubic Bézier curve, when both the coefficients and the
-- parameter are intervals. -- parameter are intervals.
evaluateCubic :: Cubic.Bezier ( 𝕀 Double ) -> 𝕀 Double -> 𝕀 Double evaluateCubic :: Cubic.Bezier 𝕀 -> 𝕀 -> 𝕀
evaluateCubic bez t = evaluateCubic bez t =
-- assert (inf t >= 0 && sup t <= 1) "evaluateCubic: t ⊊ [0,1]" $ -- Requires t ⊆ [0,1] -- assert (inf t >= 0 && sup t <= 1) "evaluateCubic: t ⊊ [0,1]" $ -- Requires t ⊆ [0,1]
let inf_bez = fmap inf bez let inf_bez = fmap inf bez
@ -472,7 +474,7 @@ evaluateCubic bez t =
-- | Evaluate a quadratic Bézier curve, when both the coefficients and the -- | Evaluate a quadratic Bézier curve, when both the coefficients and the
-- parameter are intervals. -- parameter are intervals.
evaluateQuadratic :: Quadratic.Bezier ( 𝕀 Double ) -> 𝕀 Double -> 𝕀 Double evaluateQuadratic :: Quadratic.Bezier 𝕀 -> 𝕀 -> 𝕀
evaluateQuadratic bez t = evaluateQuadratic bez t =
-- assert (inf t >= 0 && sup t <= 1) "evaluateCubic: t ⊊ [0,1]" $ -- Requires t ⊆ [0,1] -- assert (inf t >= 0 && sup t <= 1) "evaluateCubic: t ⊊ [0,1]" $ -- Requires t ⊆ [0,1]
let inf_bez = fmap inf bez let inf_bez = fmap inf bez

22
brush-strokes/src/lib/Math/Differentiable.hs
View file

@ -15,7 +15,7 @@ import GHC.TypeNats
import Math.Algebra.Dual import Math.Algebra.Dual
( D, HasChainRule ) ( D, HasChainRule )
import Math.Interval import Math.Interval
( 𝕀 ) ( 𝕀, 𝕀ℝ )
import Math.Linear import Math.Linear
import Math.Module import Math.Module
import Math.Ring import Math.Ring
@ -25,13 +25,15 @@ import Math.Ring
-- | Type family to parametrise over both pointwise and interval computations. -- | Type family to parametrise over both pointwise and interval computations.
-- --
-- Use '()' parameter for points, and '𝕀' parameter for intervals. -- Use 'ℝ' parameter for points, and '𝕀' parameter for intervals.
type I :: k -> Type -> Type type I :: k -> l -> Type
type family I i a type family I i t
type instance I () a = a type instance I @(Nat -> Type) @Type ℝ Double = Double
type instance I 𝕀 a = 𝕀 a type instance I @Type @Type 𝕀 Double = 𝕀
type instance I @(Nat -> Type) @Nat ℝ n = ℝ n
type instance I @Type @Nat 𝕀 n = 𝕀ℝ n
type Differentiable :: Nat -> k -> Type -> Constraint type Differentiable :: Nat -> k -> Nat -> Constraint
class class
( Module ( I i Double ) ( T ( I i u ) ) ( Module ( I i Double ) ( T ( I i u ) )
, HasChainRule ( I i Double ) k ( I i u ) , HasChainRule ( I i Double ) k ( I i u )
@ -43,13 +45,13 @@ instance
, Traversable ( D k ( I i u ) ) , Traversable ( D k ( I i u ) )
) => Differentiable k i u ) => Differentiable k i u
type DiffInterp :: Nat -> k -> Type -> Constraint type DiffInterp :: Nat -> k -> Nat -> Constraint
class class
( Differentiable k i u ( Differentiable k i u
, Interpolatable ( I i Double ) ( I i u ) , Interpolatable ( I i Double ) ( I i u )
, Module ( I i Double ) ( T ( I i Double ) ) , Module ( I i Double ) ( T ( I i Double ) )
, Module ( D k ( I i u ) ( I i Double ) ) , Module ( D k ( I i u ) ( I i Double ) )
( D k ( I i u ) ( I i ( ℝ 2 ) ) ) ( D k ( I i u ) ( I i 2 ) )
, Transcendental ( D k ( I i u ) ( I i Double ) ) , Transcendental ( D k ( I i u ) ( I i Double ) )
, Applicative ( D k ( I i u ) ) , Applicative ( D k ( I i u ) )
, Representable ( I i Double ) ( I i u ) , Representable ( I i Double ) ( I i u )
@ -60,7 +62,7 @@ instance
, Interpolatable ( I i Double ) ( I i u ) , Interpolatable ( I i Double ) ( I i u )
, Module ( I i Double ) ( T ( I i Double ) ) , Module ( I i Double ) ( T ( I i Double ) )
, Module ( D k ( I i u ) ( I i Double ) ) , Module ( D k ( I i u ) ( I i Double ) )
( D k ( I i u ) ( I i ( ℝ 2 ) ) ) ( D k ( I i u ) ( I i 2 ) )
, Transcendental ( D k ( I i u ) ( I i Double ) ) , Transcendental ( D k ( I i u ) ( I i Double ) )
, Applicative ( D k ( I i u ) ) , Applicative ( D k ( I i u ) )
, Representable ( I i Double ) ( I i u ) , Representable ( I i Double ) ( I i u )

310
brush-strokes/src/lib/Math/Interval.hs
View file

@ -8,14 +8,17 @@
module Math.Interval module Math.Interval
( 𝕀(𝕀), inf, sup ( 𝕀(𝕀), inf, sup
, width, midpoint , midpoint , scaleInterval, width
, scaleInterval
, 𝕀ℝ
, isCanonical , isCanonical
, singleton, nonDecreasing , (∩), (⊘), (∈), (⊖)
, (∈), (⊖), (∩), (⊘)
, extendedRecip , extendedRecip
, singleton, point
, nonDecreasing
, aabb, bisect , aabb, bisect
, 𝕀ℝ(..)
) )
where where
@ -40,7 +43,10 @@ import Math.Algebra.Dual
import Math.Float.Utils import Math.Float.Utils
( prevFP ) ( prevFP )
import Math.Interval.Internal import Math.Interval.Internal
( 𝕀(𝕀), inf, sup, scaleInterval ) ( 𝕀(𝕀), inf, sup
, scaleInterval, width, singleton
, 𝕀ℝ(..)
)
import Math.Linear import Math.Linear
( ℝ(..), T(..) ( ℝ(..), T(..)
, RepresentableQ(..), Representable(..) , RepresentableQ(..), Representable(..)
@ -52,46 +58,53 @@ import Math.Ring
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- Interval arithmetic. -- Interval arithmetic.
type 𝕀ℝ n = 𝕀 ( ℝ n ) type instance D k 𝕀 = D k Double
type instance D k ( 𝕀 v ) = D k v type instance D k ( 𝕀ℝ n ) = D k ( ℝ n )
-- | An interval reduced to a single point.
singleton :: a -> 𝕀 a
singleton a = 𝕀 a a
-- | The width of an interval.
--
-- NB: assumes the endpoints are neither @NaN@ nor infinity.
width :: AbelianGroup a => 𝕀 a -> a
width ( 𝕀 lo hi ) = hi - lo
{-# INLINEABLE width #-}
-- | Turn a non-decreasing function into a function on intervals. -- | Turn a non-decreasing function into a function on intervals.
nonDecreasing :: ( a -> b ) -> 𝕀 a -> 𝕀 b nonDecreasing :: forall n m
nonDecreasing f ( 𝕀 lo hi ) = 𝕀 ( f lo ) ( f hi ) . ( Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, Representable Double ( ℝ m )
, Representable 𝕀 ( 𝕀ℝ m ) )
=> ( ℝ n -> ℝ m ) -> 𝕀ℝ n -> 𝕀ℝ m
nonDecreasing f u =
let
lo, hi :: ℝ n
lo = tabulate \ i -> inf ( u `index` i )
hi = tabulate \ i -> sup ( u `index` i )
lo', hi' :: ℝ m
lo' = f lo
hi' = f hi
in tabulate \ j -> 𝕀 ( lo' `index` j ) ( hi' `index` j )
{-# INLINEABLE nonDecreasing #-}
-- | Does the given value lie inside the specified interval? -- | Does the given value lie inside the specified interval?
(∈) :: Ord a => a -> 𝕀 a -> Bool (∈) :: Double -> 𝕀 -> Bool
x ∈ 𝕀 lo hi = x >= lo && x <= hi x ∈ 𝕀 lo hi = x >= lo && x <= hi
{-# INLINEABLE (∈) #-}
infix 4 ∈ infix 4 ∈
-- | Is this interval canonical, i.e. it consists of either 1 or 2 floating point -- | Is this interval canonical, i.e. it consists of either 1 or 2 floating point
-- values only? -- values only?
isCanonical :: 𝕀 Double -> Bool isCanonical :: 𝕀 -> Bool
isCanonical ( 𝕀 x_inf x_sup ) = x_inf >= prevFP x_sup isCanonical ( 𝕀 x_inf x_sup ) = x_inf >= prevFP x_sup
-- | The midpoint of an interval. -- | The midpoint of an interval.
-- --
-- NB: assumes the endpoints are neither @NaN@ nor infinity. -- NB: assumes the endpoints are neither @NaN@ nor infinity.
midpoint :: 𝕀 Double -> Double midpoint :: 𝕀 -> Double
midpoint ( 𝕀 x_inf x_sup ) = 0.5 * ( x_inf + x_sup ) midpoint ( 𝕀 x_inf x_sup ) = 0.5 * ( x_inf + x_sup )
point :: ( Representable Double ( ℝ n ), Representable 𝕀 ( 𝕀ℝ n ) )
=> ℝ n -> 𝕀ℝ n
point x = tabulate \ i -> singleton ( x `index` i )
{-# INLINEABLE point #-}
-- | Compute the intersection of two intervals. -- | Compute the intersection of two intervals.
-- --
-- Returns whether the first interval is a strict subset of the second interval -- Returns whether the first interval is a strict subset of the second interval
-- (or the intersection is a single point). -- (or the intersection is a single point).
(∩) :: 𝕀 Double -> 𝕀 Double -> [ ( 𝕀 Double, Bool ) ] (∩) :: 𝕀 -> 𝕀 -> [ ( 𝕀, Bool ) ]
𝕀 lo1 hi1 ∩ 𝕀 lo2 hi2 𝕀 lo1 hi1 ∩ 𝕀 lo2 hi2
| lo > hi | lo > hi
= [ ] = [ ]
@ -102,11 +115,19 @@ midpoint ( 𝕀 x_inf x_sup ) = 0.5 * ( x_inf + x_sup )
hi = min hi1 hi2 hi = min hi1 hi2
infix 3 ∩ infix 3 ∩
infixl 6 ⊖
(⊖) :: 𝕀 -> 𝕀 -> 𝕀
(⊖) a@( 𝕀 lo1 hi1 ) b@( 𝕀 lo2 hi2 )
| width a >= width b
= 𝕀 ( lo1 - lo2 ) ( hi1 - hi2 )
| otherwise
= 𝕀 ( hi1 - hi2 ) ( lo1 - lo2 )
-- | Bisect an interval. -- | Bisect an interval.
-- --
-- Generally returns two sub-intervals, but returns the input interval if -- Generally returns two sub-intervals, but returns the input interval if
-- it is canonical (and thus bisection would be pointless). -- it is canonical (and thus bisection would be pointless).
bisect :: 𝕀 Double -> NE.NonEmpty ( 𝕀 Double ) bisect :: 𝕀 -> NE.NonEmpty 𝕀
bisect x@( 𝕀 x_inf x_sup ) bisect x@( 𝕀 x_inf x_sup )
| isCanonical x | isCanonical x
= NE.singleton x = NE.singleton x
@ -114,25 +135,16 @@ bisect x@( 𝕀 x_inf x_sup )
= 𝕀 x_inf x_mid NE.:| [ 𝕀 x_mid x_sup ] = 𝕀 x_inf x_mid NE.:| [ 𝕀 x_mid x_sup ]
where x_mid = midpoint x where x_mid = midpoint x
infixl 6 ⊖ deriving via ViaAbelianGroup ( T 𝕀 )
(⊖) :: ( AbelianGroup a, Ord a ) => 𝕀 a -> 𝕀 a -> 𝕀 a instance Semigroup ( T 𝕀 )
(⊖) a@( 𝕀 lo1 hi1 ) b@( 𝕀 lo2 hi2 ) deriving via ViaAbelianGroup ( T 𝕀 )
| width a >= width b instance Monoid ( T 𝕀 )
= 𝕀 ( lo1 - lo2 ) ( hi1 - hi2 ) deriving via ViaAbelianGroup ( T 𝕀 )
| otherwise instance Group ( T 𝕀 )
= 𝕀 ( hi1 - hi2 ) ( lo1 - lo2 )
{-# INLINEABLE (⊖) #-}
deriving via ViaAbelianGroup ( T ( 𝕀 Double ) ) instance Act ( T 𝕀 ) 𝕀 where
instance Semigroup ( T ( 𝕀 Double ) )
deriving via ViaAbelianGroup ( T ( 𝕀 Double ) )
instance Monoid ( T ( 𝕀 Double ) )
deriving via ViaAbelianGroup ( T ( 𝕀 Double ) )
instance Group ( T ( 𝕀 Double ) )
instance Act ( T ( 𝕀 Double ) ) ( 𝕀 Double ) where
T g • a = g + a T g • a = g + a
instance Torsor ( T ( 𝕀 Double ) ) ( 𝕀 Double ) where instance Torsor ( T 𝕀 ) 𝕀 where
a --> b = T $ b - a a --> b = T $ b - a
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
@ -142,7 +154,7 @@ instance Torsor ( T ( 𝕀 Double ) ) ( 𝕀 Double ) where
-- --
-- NB: this function can return overlapping intervals if both arguments contain 0. -- NB: this function can return overlapping intervals if both arguments contain 0.
-- Otherwise, the returned intervals are guaranteed to be disjoint. -- Otherwise, the returned intervals are guaranteed to be disjoint.
(⊘) :: 𝕀 Double -> 𝕀 Double -> [ 𝕀 Double ] (⊘) :: 𝕀 -> 𝕀 -> [ 𝕀 ]
x ⊘ y x ⊘ y
#ifdef ASSERTS #ifdef ASSERTS
| 0 ∈ x && 0 ∈ y | 0 ∈ x && 0 ∈ y
@ -155,7 +167,7 @@ x ⊘ y
infixl 7 ⊘ infixl 7 ⊘
-- | Extended reciprocal, returning either 1 or 2 intervals. -- | Extended reciprocal, returning either 1 or 2 intervals.
extendedRecip :: 𝕀 Double -> [ 𝕀 Double ] extendedRecip :: 𝕀 -> [ 𝕀 ]
extendedRecip x@( 𝕀 lo hi ) extendedRecip x@( 𝕀 lo hi )
| lo == 0 && hi == 0 | lo == 0 && hi == 0
= [ 𝕀 negInf posInf ] = [ 𝕀 negInf posInf ]
@ -172,85 +184,77 @@ posInf = 1 / 0
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
-- Lattices. -- Lattices.
aabb :: ( Representable r v, Ord r, Functor f ) aabb :: ( Representable 𝕀 ( 𝕀ℝ n ), Functor f )
=> f ( 𝕀 v ) -> ( f ( 𝕀 r ) -> 𝕀 r ) -> 𝕀 v => f ( 𝕀ℝ n ) -> ( f 𝕀 -> 𝕀 ) -> 𝕀ℝ n
aabb fv extrema = tabulate \ i -> extrema ( fmap ( `index` i ) fv ) aabb fv extrema = tabulate \ i -> extrema ( fmap ( `index` i ) fv )
{-# INLINEABLE aabb #-} {-# INLINEABLE aabb #-}
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ 0 ) ) where instance Module 𝕀 ( T ( 𝕀ℝ 0 ) ) where
origin = T $ singleton ℝ0 origin = T 𝕀ℝ0
_ ^+^ _ = T $ singleton ℝ0 _ ^+^ _ = T 𝕀ℝ0
_ ^-^ _ = T $ singleton ℝ0 _ ^-^ _ = T 𝕀ℝ0
_ *^ _ = T $ singleton ℝ0 _ *^ _ = T 𝕀ℝ0
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ 1 ) ) where instance Module 𝕀 ( T ( 𝕀ℝ 1 ) ) where
origin = T $$( tabulateQ \ _ -> [|| unT $ origin ||] ) origin = T $ 𝕀ℝ1 ( unT origin )
T a ^+^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^+^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ1 x1 ) ^+^ T ( 𝕀ℝ1 x2 ) = T $ 𝕀ℝ1 ( x1 + x2 )
T a ^-^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^-^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ1 x1 ) ^-^ T ( 𝕀ℝ1 x2 ) = T $ 𝕀ℝ1 ( x1 - x2 )
k *^ T a = T $$( tabulateQ \ i -> [|| unT $ k *^ T $$( indexQ [|| a ||] i ) ||] ) k *^ T ( 𝕀ℝ1 x1 ) = T $ 𝕀ℝ1 ( k * x1 )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ 2 ) ) where instance Module 𝕀 ( T ( 𝕀ℝ 2 ) ) where
origin = T $$( tabulateQ \ _ -> [|| unT $ origin ||] ) origin = T $ 𝕀ℝ2 ( unT origin ) ( unT origin )
T a ^+^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^+^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ2 x1 y1 ) ^+^ T ( 𝕀ℝ2 x2 y2 ) = T $ 𝕀ℝ2 ( x1 + x2 ) ( y1 + y2 )
T a ^-^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^-^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ2 x1 y1 ) ^-^ T ( 𝕀ℝ2 x2 y2 ) = T $ 𝕀ℝ2 ( x1 - x2 ) ( y1 - y2 )
k *^ T a = T $$( tabulateQ \ i -> [|| unT $ k *^ T $$( indexQ [|| a ||] i ) ||] ) k *^ T ( 𝕀ℝ2 x1 y1 ) = T $ 𝕀ℝ2 ( k * x1 ) ( k * y1 )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ 3 ) ) where instance Module 𝕀 ( T ( 𝕀ℝ 3 ) ) where
origin = T $$( tabulateQ \ _ -> [|| unT $ origin ||] ) origin = T $ 𝕀ℝ3 ( unT origin ) ( unT origin ) ( unT origin )
T a ^+^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^+^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ3 x1 y1 z1 ) ^+^ T ( 𝕀ℝ3 x2 y2 z2 ) = T $ 𝕀ℝ3 ( x1 + x2 ) ( y1 + y2 ) ( z1 + z2 )
T a ^-^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^-^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ3 x1 y1 z1 ) ^-^ T ( 𝕀ℝ3 x2 y2 z2 ) = T $ 𝕀ℝ3 ( x1 - x2 ) ( y1 - y2 ) ( z1 - z2 )
k *^ T a = T $$( tabulateQ \ i -> [|| unT $ k *^ T $$( indexQ [|| a ||] i ) ||] ) k *^ T ( 𝕀ℝ3 x1 y1 z1 ) = T $ 𝕀ℝ3 ( k * x1 ) ( k * y1 ) ( k * z1 )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ 4 ) ) where instance Module 𝕀 ( T ( 𝕀ℝ 4 ) ) where
origin = T $$( tabulateQ \ _ -> [|| unT $ origin ||] ) origin = T $ 𝕀ℝ4 ( unT origin ) ( unT origin ) ( unT origin ) ( unT origin )
T a ^+^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^+^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ4 x1 y1 z1 w1 ) ^+^ T ( 𝕀ℝ4 x2 y2 z2 w2 ) = T $ 𝕀ℝ4 ( x1 + x2 ) ( y1 + y2 ) ( z1 + z2 ) ( w1 + w2 )
T a ^-^ T b = T $$( tabulateQ \ i -> [|| unT $ T $$( indexQ [|| a ||] i ) ^-^ T $$( indexQ [|| b ||] i ) ||] ) T ( 𝕀ℝ4 x1 y1 z1 w1 ) ^-^ T ( 𝕀ℝ4 x2 y2 z2 w2 ) = T $ 𝕀ℝ4 ( x1 - x2 ) ( y1 - y2 ) ( z1 - z2 ) ( w1 - w2 )
k *^ T a = T $$( tabulateQ \ i -> [|| unT $ k *^ T $$( indexQ [|| a ||] i ) ||] ) k *^ T ( 𝕀ℝ4 x1 y1 z1 w1 ) = T $ 𝕀ℝ4 ( k * x1 ) ( k * y1 ) ( k * z1 ) ( k * w1 )
instance Inner ( 𝕀 Double ) ( T ( 𝕀ℝ 2 ) ) where instance Inner 𝕀 ( T ( 𝕀ℝ 2 ) ) where
T ( 𝕀 ( ℝ2 x1_lo y1_lo ) ( ℝ2 x1_hi y1_hi ) ) ^.^ T ( 𝕀ℝ2 x1 y1 ) ^.^ T ( 𝕀ℝ2 x2 y2 ) = x1 * x2 + y1 * y2
T ( 𝕀 ( ℝ2 x2_lo y2_lo ) ( ℝ2 x2_hi y2_hi ) )
= let !x1x2 = 𝕀 x1_lo x1_hi * 𝕀 x2_lo x2_hi
!y1y2 = 𝕀 y1_lo y1_hi * 𝕀 y2_lo y2_hi
in x1x2 + y1y2
instance Cross ( 𝕀 Double ) ( T ( 𝕀ℝ 2 ) ) where instance Cross 𝕀 ( T ( 𝕀ℝ 2 ) ) where
T ( 𝕀 ( ℝ2 x1_lo y1_lo ) ( ℝ2 x1_hi y1_hi ) ) × T ( 𝕀ℝ2 x1 y1 ) × T ( 𝕀ℝ2 x2 y2 ) = x1 * y2 - x2 * y1
T ( 𝕀 ( ℝ2 x2_lo y2_lo ) ( ℝ2 x2_hi y2_hi ) )
= let !x1y2 = 𝕀 x1_lo x1_hi * 𝕀 y2_lo y2_hi
!y2x1 = 𝕀 x2_lo x2_hi * 𝕀 y1_lo y1_hi
in x1y2 - y2x1
deriving via ViaModule ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) deriving via ViaModule 𝕀 ( T ( 𝕀ℝ n ) )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) => Semigroup ( T ( 𝕀ℝ n ) ) instance Module 𝕀 ( T ( 𝕀ℝ n ) ) => Semigroup ( T ( 𝕀ℝ n ) )
deriving via ViaModule ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) deriving via ViaModule 𝕀 ( T ( 𝕀ℝ n ) )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) => Monoid ( T ( 𝕀ℝ n ) ) instance Module 𝕀 ( T ( 𝕀ℝ n ) ) => Monoid ( T ( 𝕀ℝ n ) )
deriving via ViaModule ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) deriving via ViaModule 𝕀 ( T ( 𝕀ℝ n ) )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) => Group ( T ( 𝕀ℝ n ) ) instance Module 𝕀 ( T ( 𝕀ℝ n ) ) => Group ( T ( 𝕀ℝ n ) )
deriving via ViaModule ( 𝕀 Double ) ( 𝕀ℝ n ) deriving via ViaModule 𝕀 ( 𝕀ℝ n )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) => Act ( T ( 𝕀ℝ n ) ) ( 𝕀ℝ n ) instance Module 𝕀 ( T ( 𝕀ℝ n ) ) => Act ( T ( 𝕀ℝ n ) ) ( 𝕀ℝ n )
deriving via ( ViaModule ( 𝕀 Double ) ( 𝕀ℝ n ) ) deriving via ( ViaModule 𝕀 ( 𝕀ℝ n ) )
instance Module ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) => Torsor ( T ( 𝕀ℝ n ) ) ( 𝕀ℝ n ) instance Module 𝕀 ( T ( 𝕀ℝ n ) ) => Torsor ( T ( 𝕀ℝ n ) ) ( 𝕀ℝ n )
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- HasChainRule instances. -- HasChainRule instances.
instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 0 ) where instance HasChainRule 𝕀 2 ( 𝕀ℝ 0 ) where
konst w = D0 w konst w = D0 w
linearD f v = D0 ( f v ) linearD f v = D0 ( f v )
value ( D0 v ) = v value ( D0 v ) = v
chain _ ( D0 gfx ) = D21 gfx origin origin chain _ ( D0 gfx ) = D21 gfx origin origin
instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 0 ) where instance HasChainRule 𝕀 3 ( 𝕀ℝ 0 ) where
konst w = D0 w konst w = D0 w
linearD f v = D0 ( f v ) linearD f v = D0 ( f v )
value ( D0 v ) = v value ( D0 v ) = v
chain _ ( D0 gfx ) = D31 gfx origin origin origin chain _ ( D0 gfx ) = D31 gfx origin origin origin
instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 1 ) where instance HasChainRule 𝕀 2 ( 𝕀ℝ 1 ) where
konst :: forall w. AbelianGroup w => w -> D2𝔸1 w konst :: forall w. AbelianGroup w => w -> D2𝔸1 w
konst w = konst w =
@ -259,9 +263,9 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 1 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 1 -> w ) -> 𝕀ℝ 1 -> D2𝔸1 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 1 -> w ) -> 𝕀ℝ 1 -> D2𝔸1 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -276,16 +280,16 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 1 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D2𝔸1 ( 𝕀ℝ 1 ) -> D2𝔸1 w -> D2𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D2𝔸1 ( 𝕀ℝ 1 ) -> D2𝔸1 w -> D2𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 1 ) where instance HasChainRule 𝕀 3 ( 𝕀ℝ 1 ) where
konst :: forall w. AbelianGroup w => w -> D3𝔸1 w konst :: forall w. AbelianGroup w => w -> D3𝔸1 w
konst w = konst w =
@ -294,9 +298,9 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 1 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 1 -> w ) -> 𝕀ℝ 1 -> D3𝔸1 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 1 -> w ) -> 𝕀ℝ 1 -> D3𝔸1 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -311,16 +315,16 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 1 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D3𝔸1 ( 𝕀ℝ 1 ) -> D3𝔸1 w -> D3𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D3𝔸1 ( 𝕀ℝ 1 ) -> D3𝔸1 w -> D3𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 2 ) where instance HasChainRule 𝕀 2 ( 𝕀ℝ 2 ) where
konst :: forall w. AbelianGroup w => w -> D2𝔸2 w konst :: forall w. AbelianGroup w => w -> D2𝔸2 w
konst w = konst w =
@ -329,9 +333,9 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 2 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 2 -> w ) -> 𝕀ℝ 2 -> D2𝔸2 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 2 -> w ) -> 𝕀ℝ 2 -> D2𝔸2 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -346,16 +350,16 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 2 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D2𝔸1 ( 𝕀ℝ 2 ) -> D2𝔸2 w -> D2𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D2𝔸1 ( 𝕀ℝ 2 ) -> D2𝔸2 w -> D2𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 2 ) where instance HasChainRule 𝕀 3 ( 𝕀ℝ 2 ) where
konst :: forall w. AbelianGroup w => w -> D3𝔸2 w konst :: forall w. AbelianGroup w => w -> D3𝔸2 w
konst w = konst w =
@ -364,9 +368,9 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 2 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 2 -> w ) -> 𝕀ℝ 2 -> D3𝔸2 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 2 -> w ) -> 𝕀ℝ 2 -> D3𝔸2 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -381,16 +385,16 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 2 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D3𝔸1 ( 𝕀ℝ 2 ) -> D3𝔸2 w -> D3𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D3𝔸1 ( 𝕀ℝ 2 ) -> D3𝔸2 w -> D3𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 3 ) where instance HasChainRule 𝕀 2 ( 𝕀ℝ 3 ) where
konst :: forall w. AbelianGroup w => w -> D2𝔸3 w konst :: forall w. AbelianGroup w => w -> D2𝔸3 w
konst w = konst w =
@ -399,9 +403,9 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 3 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 3 -> w ) -> 𝕀ℝ 3 -> D2𝔸3 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 3 -> w ) -> 𝕀ℝ 3 -> D2𝔸3 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -416,16 +420,16 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 3 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D2𝔸1 ( 𝕀ℝ 3 ) -> D2𝔸3 w -> D2𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D2𝔸1 ( 𝕀ℝ 3 ) -> D2𝔸3 w -> D2𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 3 ) where instance HasChainRule 𝕀 3 ( 𝕀ℝ 3 ) where
konst :: forall w. AbelianGroup w => w -> D3𝔸3 w konst :: forall w. AbelianGroup w => w -> D3𝔸3 w
konst w = konst w =
@ -434,9 +438,9 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 3 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 3 -> w ) -> 𝕀ℝ 3 -> D3𝔸3 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 3 -> w ) -> 𝕀ℝ 3 -> D3𝔸3 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -451,16 +455,16 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 3 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D3𝔸1 ( 𝕀ℝ 3 ) -> D3𝔸3 w -> D3𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D3𝔸1 ( 𝕀ℝ 3 ) -> D3𝔸3 w -> D3𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 4 ) where instance HasChainRule 𝕀 2 ( 𝕀ℝ 4 ) where
konst :: forall w. AbelianGroup w => w -> D2𝔸4 w konst :: forall w. AbelianGroup w => w -> D2𝔸4 w
konst w = konst w =
@ -469,9 +473,9 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 4 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 4 -> w ) -> 𝕀ℝ 4 -> D2𝔸4 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 4 -> w ) -> 𝕀ℝ 4 -> D2𝔸4 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -486,16 +490,16 @@ instance HasChainRule ( 𝕀 Double ) 2 ( 𝕀ℝ 4 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D2𝔸1 ( 𝕀ℝ 4 ) -> D2𝔸4 w -> D2𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D2𝔸1 ( 𝕀ℝ 4 ) -> D2𝔸4 w -> D2𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )
instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 4 ) where instance HasChainRule 𝕀 3 ( 𝕀ℝ 4 ) where
konst :: forall w. AbelianGroup w => w -> D3𝔸4 w konst :: forall w. AbelianGroup w => w -> D3𝔸4 w
konst w = konst w =
@ -504,9 +508,9 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 4 ) where
value df = $$( monIndexQ [|| df ||] zeroMonomial ) value df = $$( monIndexQ [|| df ||] zeroMonomial )
linearD :: forall w. Module ( 𝕀 Double ) ( T w ) => ( 𝕀ℝ 4 -> w ) -> 𝕀ℝ 4 -> D3𝔸4 w linearD :: forall w. Module 𝕀 ( T w ) => ( 𝕀ℝ 4 -> w ) -> 𝕀ℝ 4 -> D3𝔸4 w
linearD f v = linearD f v =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
in $$( monTabulateQ \ mon -> in $$( monTabulateQ \ mon ->
if | isZeroMonomial mon if | isZeroMonomial mon
-> [|| f v ||] -> [|| f v ||]
@ -521,11 +525,11 @@ instance HasChainRule ( 𝕀 Double ) 3 ( 𝕀ℝ 4 ) where
-> [|| unT o ||] -> [|| unT o ||]
) )
chain :: forall w. Module ( 𝕀 Double ) ( T w ) => D3𝔸1 ( 𝕀ℝ 4 ) -> D3𝔸4 w -> D3𝔸1 w chain :: forall w. Module 𝕀 ( T w ) => D3𝔸1 ( 𝕀ℝ 4 ) -> D3𝔸4 w -> D3𝔸1 w
chain !df !dg = chain !df !dg =
let !o = origin @( 𝕀 Double ) @( T w ) let !o = origin @𝕀 @( T w )
!p = (^+^) @( 𝕀 Double ) @( T w ) !p = (^+^) @𝕀 @( T w )
!s = (^*) @( 𝕀 Double ) @( T w ) !s = (^*) @𝕀 @( T w )
in $$( chainRule1NQ in $$( chainRule1NQ
[|| o ||] [|| p ||] [|| s ||] [|| o ||] [|| p ||] [|| s ||]
[|| df ||] [|| dg ||] ) [|| df ||] [|| dg ||] )

92
brush-strokes/src/lib/Math/Interval/FMA.hs
View file

@ -1,92 +0,0 @@
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Math.Interval.FMA
( addI, subI, prodI, divI, posPowI )
where
-- base
import GHC.Exts
( Double(D#), fmsubDouble#, fnmaddDouble# )
-- brush-strokes
import Math.Float.Utils
( prevFP, succFP )
--------------------------------------------------------------------------------
{-# INLINE withError #-}
withError :: Double -> Double -> ( Double, Double )
withError f e =
case compare e 0 of
LT -> ( prevFP f, f )
EQ -> ( f, f )
GT -> ( f, succFP f )
addI :: Double -> Double -> ( Double, Double )
addI a b =
let !s = a + b
!a' = s - b
!b' = s - a'
!da = a - a'
!db = b - b'
!e = da + db
in s `withError` e
subI :: Double -> Double -> ( Double, Double )
subI a b =
let !s = a - b
!a' = s - b
!b' = s - a'
!da = a - a'
!db = b - b'
!e = da + db
in s `withError` e
{-# INLINE fmsubDouble #-}
fmsubDouble :: Double -> Double -> Double -> Double
fmsubDouble ( D# x ) ( D# y ) ( D# z ) = D# ( fmsubDouble# x y z )
{-# INLINE fnmaddDouble #-}
fnmaddDouble :: Double -> Double -> Double -> Double
fnmaddDouble ( D# x ) ( D# y ) ( D# z ) = D# ( fnmaddDouble# x y z )
prodI :: Double -> Double -> ( Double, Double )
prodI a b =
let !p = a * b
!e = fmsubDouble a b p
in p `withError` e
divI :: Double -> Double -> ( Double, Double )
divI a b =
let !r = a / b
!e = fnmaddDouble r b a
in r `withError` e
-- | Power of a **non-negative** number to a natural power.
posPowI :: Double -- ^ Assumed to be non-negative!
-> Word -> ( Double, Double )
posPowI _ 0 = ( 1, 1 )
posPowI f 1 = ( f, f )
posPowI f 2 = prodI f f
posPowI f n
| even n
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
= ( fst $ posPowI f²_lo m, snd $ posPowI f²_hi m )
| otherwise
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
= ( fst $ posPowAcc f²_lo m f, snd $ posPowAcc f²_hi m f )
posPowAcc :: Double -> Word -> Double -> ( Double, Double )
posPowAcc f 1 x = prodI f x
posPowAcc f n x
| even n
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
= ( fst $ posPowAcc f²_lo m x, snd $ posPowAcc f²_hi m x )
| otherwise
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
( y_lo, y_hi ) = prodI f x
= ( fst $ posPowAcc f²_lo m y_lo, snd $ posPowAcc f²_hi m y_hi )

297
brush-strokes/src/lib/Math/Interval/Internal.hs
View file

@ -6,190 +6,68 @@
{-# OPTIONS_GHC -Wno-orphans #-} {-# OPTIONS_GHC -Wno-orphans #-}
module Math.Interval.Internal module Math.Interval.Internal
( 𝕀(𝕀, inf, sup), scaleInterval ) ( 𝕀(𝕀, inf, sup)
, scaleInterval, width, singleton
, 𝕀ℝ(..)
)
where where
-- base -- base
import Prelude hiding ( Num(..), Fractional(..), Floating(..), (^) ) import Prelude hiding ( Num(..), Fractional(..), Floating(..), (^) )
import qualified Prelude import Data.Kind
( Type )
import Data.Monoid import Data.Monoid
( Sum(..) ) ( Sum(..) )
import GHC.Generics
( Generic )
import GHC.Show import GHC.Show
( showCommaSpace ) ( showCommaSpace )
import GHC.TypeNats
( Nat )
-- deepseq -- deepseq
import Control.DeepSeq import Control.DeepSeq
( NFData(..) ) ( NFData(..) )
-- rounded-hw
import Numeric.Rounded.Hardware
( Rounded(..) )
import qualified Numeric.Rounded.Hardware.Interval.NonEmpty as Interval
( Interval(..) )
#ifdef USE_FMA
-- brush-strokes -- brush-strokes
import Math.Interval.FMA #if defined(USE_SIMD)
( addI, subI, prodI, divI, posPowI ) import Math.Interval.Internal.SIMD
#elif defined(USE_FMA)
import Math.Interval.Internal.FMA
#else #else
-- rounded-hw import Math.Interval.Internal.RoundedHW
import qualified Numeric.Rounded.Hardware.Interval.NonEmpty as Interval
( powInt )
#endif #endif
-- brush-strokes -- brush-strokes
import Math.Linear import Math.Linear
( T(..) ( T(..)
, RepDim, RepresentableQ(..), Representable(..) , RepDim, RepresentableQ(..), Representable(..)
, Fin(..)
) )
import Math.Module import Math.Module
( Module(..) ) ( Module(..) )
import Math.Ring import Math.Ring
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- Intervals.
#ifdef USE_FMA -- | An interval reduced to a single point.
data 𝕀 a = 𝕀 { inf, sup :: !a } singleton :: Double -> 𝕀
singleton x = 𝕀 x x
instance NFData a => NFData ( 𝕀 a ) where -- | The width of an interval.
rnf ( 𝕀 lo hi ) = rnf lo `seq` rnf hi --
-- NB: assumes the endpoints are neither @NaN@ nor infinity.
instance Prelude.Num ( 𝕀 Double ) where width :: 𝕀 -> Double
𝕀 x_lo x_hi + 𝕀 y_lo y_hi width ( 𝕀 lo hi ) = hi - lo
| let !z_lo = fst $ addI x_lo y_lo
!z_hi = snd $ addI x_hi y_hi
= 𝕀 z_lo z_hi
𝕀 x_lo x_hi - 𝕀 y_lo y_hi
| let !z_lo = fst $ subI x_lo y_hi
!z_hi = snd $ subI x_hi y_lo
= 𝕀 z_lo z_hi
negate (𝕀 lo hi) = 𝕀 (Prelude.negate hi) (Prelude.negate lo)
(*) = (*)
fromInteger i =
let !j = Prelude.fromInteger i
in 𝕀 j j
abs (𝕀 lo hi)
| 0 <= lo
= 𝕀 lo hi
| hi <= 0
= 𝕀 (Prelude.negate hi) (Prelude.negate lo)
| otherwise
= 𝕀 0 (max (Prelude.negate lo) hi)
signum _ = error "No implementation of signum for intervals"
instance Ring ( 𝕀 Double ) where
𝕀 lo1 hi1 * 𝕀 lo2 hi2
| let !( x_min, x_max ) = prodI lo1 lo2
!( y_min, y_max ) = prodI lo1 hi2
!( z_min, z_max ) = prodI hi1 lo2
!( w_min, w_max ) = prodI hi1 hi2
= 𝕀 ( min ( min x_min y_min ) ( min z_min w_min ) )
( max ( max x_max y_max ) ( max z_max w_max ) )
_ ^ 0 = 𝕀 1 1
iv ^ 1 = iv
𝕀 lo hi ^ n
| odd n || 0 <= lo
, let !lo' = fst $ posPowI lo n
!hi' = snd $ posPowI hi n
= 𝕀 lo' hi'
| hi <= 0
, let !lo' = fst $ posPowI (negate hi) n
!hi' = snd $ posPowI (negate lo) n
= 𝕀 lo' hi'
| otherwise
, let !hi1 = snd $ posPowI (negate lo) n
, let !hi2 = snd $ posPowI hi n
= 𝕀 0 ( max hi1 hi2 )
instance Prelude.Fractional ( 𝕀 Double ) where
fromRational r =
let q = Prelude.fromRational r
in 𝕀 q q
recip ( 𝕀 lo hi )
-- #ifdef ASSERTS
| lo == 0
= 𝕀 ( fst $ divI 1 hi ) ( 1 Prelude./ 0 )
| hi == 0
= 𝕀 ( -1 Prelude./ 0 ) ( snd $ divI 1 lo )
| lo > 0 || hi < 0
-- #endif
= 𝕀 ( fst $ divI 1 hi ) ( snd $ divI 1 lo )
-- #ifdef ASSERTS
| otherwise
= error "BAD interval recip; should use extendedRecip instead"
-- #endif
p / q = p * Prelude.recip q
instance Floating ( 𝕀 Double ) where
sqrt = withHW Prelude.sqrt
instance Transcendental ( 𝕀 Double ) where
pi = 𝕀 3.141592653589793 3.1415926535897936
cos = withHW Prelude.cos
sin = withHW Prelude.sin
atan = withHW Prelude.atan
{-
TODO: consider using https://github.com/JishinMaster/simd_utils/blob/160c50f07e08d2077ae4368f0aed2f10f7173c67/simd_utils_sse_double.h#L530
for sin/cos? Or Intel SVML? Or metalibm?
-}
{-# INLINE withHW #-}
-- | Internal function: use @rounded-hw@ to define a function on intervals.
withHW :: (Interval.Interval a -> Interval.Interval b) -> 𝕀 a -> 𝕀 b
withHW f = \ ( 𝕀 lo hi ) ->
case f ( Interval.I ( Rounded lo ) ( Rounded hi ) ) of
Interval.I ( Rounded x ) ( Rounded y ) -> 𝕀 x y
scaleInterval :: Double -> 𝕀 Double -> 𝕀 Double
scaleInterval s ( 𝕀 lo hi ) =
case compare s 0 of
LT -> 𝕀 ( fst $ prodI s hi ) ( snd $ prodI s lo )
EQ -> 𝕀 0 0
GT -> 𝕀 ( fst $ prodI s lo ) ( snd $ prodI s hi )
#else
newtype 𝕀 a = MkI { ival :: Interval.Interval a }
deriving newtype ( Prelude.Num, Prelude.Fractional, Prelude.Floating )
deriving newtype NFData
{-# COMPLETE 𝕀 #-}
pattern 𝕀 :: a -> a -> 𝕀 a
pattern 𝕀 { inf, sup } = MkI ( Interval.I ( Rounded inf ) ( Rounded sup ) )
instance Ring ( 𝕀 Double ) where
MkI i1 * MkI i2 = MkI $ i1 Prelude.* i2
MkI x ^ n = MkI { ival = Interval.powInt x ( Prelude.fromIntegral n ) }
-- This is very important, as x^2 is not the same as x * x
-- in interval arithmetic. This ensures we don't
-- accidentally use (^) from Prelude.
deriving via ViaPrelude ( 𝕀 Double )
instance Floating ( 𝕀 Double )
deriving via ViaPrelude ( 𝕀 Double )
instance Transcendental ( 𝕀 Double )
scaleInterval :: Double -> 𝕀 Double -> 𝕀 Double
scaleInterval s iv = 𝕀 s s * iv -- TODO: could be better
#endif
deriving via ViaPrelude ( 𝕀 Double )
instance AbelianGroup ( 𝕀 Double )
deriving via ViaPrelude ( 𝕀 Double )
instance AbelianGroup ( T ( 𝕀 Double ) )
deriving via ViaPrelude ( 𝕀 Double )
instance Field ( 𝕀 Double )
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- Instances for (1D) intervals.
instance Eq a => Eq ( 𝕀 a ) where instance Eq 𝕀 where
𝕀 a b == 𝕀 c d = 𝕀 a b == 𝕀 c d =
a == c && b == d a == c && b == d
instance Show a => Show ( 𝕀 a ) where instance Show 𝕀 where
showsPrec _ ( 𝕀 x y ) showsPrec _ ( 𝕀 x y )
= showString "[" = showString "["
. showsPrec 0 x . showsPrec 0 x
@ -197,35 +75,104 @@ instance Show a => Show ( 𝕀 a ) where
. showsPrec 0 y . showsPrec 0 y
. showString "]" . showString "]"
deriving via ViaPrelude 𝕀
instance AbelianGroup ( T 𝕀 )
deriving via Sum 𝕀
instance Module 𝕀 ( T 𝕀 )
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
type instance RepDim ( 𝕀 u ) = RepDim u type 𝕀ℝ :: Nat -> Type
instance RepresentableQ r u => RepresentableQ ( 𝕀 r ) ( 𝕀 u ) where data family 𝕀ℝ n
tabulateQ f =
let !lo = tabulateQ @r @u ( \ i -> [|| inf $ $$( f i ) ||] )
!hi = tabulateQ @r @u ( \ i -> [|| sup $ $$( f i ) ||] )
in [|| 𝕀 $$lo $$hi ||]
indexQ d i = data instance 𝕀ℝ 0 = 𝕀ℝ0
[|| case $$d of deriving stock ( Show, Eq, Ord, Generic )
𝕀 lo hi -> deriving anyclass NFData
let !lo_i = $$( indexQ @r @u [|| lo ||] i ) newtype instance 𝕀ℝ 1 = 𝕀ℝ1 { un𝕀ℝ1 :: 𝕀 }
!hi_i = $$( indexQ @r @u [|| hi ||] i ) deriving stock ( Show, Generic )
in 𝕀 lo_i hi_i deriving newtype ( Eq, NFData )
||] data instance 𝕀ℝ 2 = 𝕀ℝ2 { _𝕀ℝ2_x, _𝕀ℝ2_y :: !𝕀 }
instance Representable r u => Representable ( 𝕀 r ) ( 𝕀 u ) where deriving stock Generic
tabulate f = deriving anyclass NFData
let !lo = tabulate @r @u ( \ i -> inf $ f i ) deriving stock ( Show, Eq )
!hi = tabulate @r @u ( \ i -> sup $ f i ) data instance 𝕀ℝ 3 = 𝕀ℝ3 { _𝕀ℝ3_x, _𝕀ℝ3_y, _𝕀ℝ3_z :: !𝕀 }
in 𝕀 lo hi deriving stock Generic
deriving anyclass NFData
deriving stock ( Show, Eq )
data instance 𝕀ℝ 4 = 𝕀ℝ4 { _𝕀ℝ4_x, _𝕀ℝ4_y, _𝕀ℝ4_z, _𝕀ℝ4_w :: !𝕀 }
deriving stock Generic
deriving anyclass NFData
deriving stock ( Show, Eq )
type instance RepDim ( 𝕀ℝ n ) = n
instance RepresentableQ 𝕀 ( 𝕀ℝ 0 ) where
tabulateQ _ = [|| 𝕀ℝ0 ||]
indexQ _ _ = [|| 0 ||]
instance RepresentableQ 𝕀 ( 𝕀ℝ 1 ) where
tabulateQ f = [|| 𝕀ℝ1 $$( f ( Fin 1 ) ) ||]
indexQ p = \ case
_ -> [|| un𝕀ℝ1 $$p ||]
instance RepresentableQ 𝕀 ( 𝕀ℝ 2 ) where
tabulateQ f = [|| 𝕀ℝ2 $$( f ( Fin 1 ) ) $$( f ( Fin 2 ) ) ||]
indexQ p = \ case
Fin 1 -> [|| _𝕀ℝ2_x $$p ||]
_ -> [|| _𝕀ℝ2_y $$p ||]
instance RepresentableQ 𝕀 ( 𝕀ℝ 3 ) where
tabulateQ f = [|| 𝕀ℝ3 $$( f ( Fin 1 ) ) $$( f ( Fin 2 ) ) $$( f ( Fin 3 ) ) ||]
indexQ p = \ case
Fin 1 -> [|| _𝕀ℝ3_x $$p ||]
Fin 2 -> [|| _𝕀ℝ3_y $$p ||]
_ -> [|| _𝕀ℝ3_z $$p ||]
instance RepresentableQ 𝕀 ( 𝕀ℝ 4 ) where
tabulateQ f = [|| 𝕀ℝ4 $$( f ( Fin 1 ) ) $$( f ( Fin 2 ) ) $$( f ( Fin 3 ) ) $$( f ( Fin 4 ) ) ||]
indexQ p = \ case
Fin 1 -> [|| _𝕀ℝ4_x $$p ||]
Fin 2 -> [|| _𝕀ℝ4_y $$p ||]
Fin 3 -> [|| _𝕀ℝ4_z $$p ||]
_ -> [|| _𝕀ℝ4_w $$p ||]
instance Representable 𝕀 ( 𝕀ℝ 0 ) where
tabulate _ = 𝕀ℝ0
{-# INLINE tabulate #-} {-# INLINE tabulate #-}
index _ _ = 0
index d i =
case d of
𝕀 lo hi ->
let !lo_i = index @r @u lo i
!hi_i = index @r @u hi i
in 𝕀 lo_i hi_i
{-# INLINE index #-} {-# INLINE index #-}
deriving via Sum ( 𝕀 Double ) instance Module ( 𝕀 Double ) ( T ( 𝕀 Double ) ) instance Representable 𝕀 ( 𝕀ℝ 1 ) where
tabulate f = 𝕀ℝ1 ( f ( Fin 1 ) )
{-# INLINE tabulate #-}
index p = \ case
_ -> un𝕀ℝ1 p
{-# INLINE index #-}
instance Representable 𝕀 ( 𝕀ℝ 2 ) where
tabulate f = 𝕀ℝ2 ( f ( Fin 1 ) ) ( f ( Fin 2 ) )
{-# INLINE tabulate #-}
index p = \ case
Fin 1 -> _𝕀ℝ2_x p
_ -> _𝕀ℝ2_y p
{-# INLINE index #-}
instance Representable 𝕀 ( 𝕀ℝ 3 ) where
tabulate f = 𝕀ℝ3 ( f ( Fin 1 ) ) ( f ( Fin 2 ) ) ( f ( Fin 3 ) )
{-# INLINE tabulate #-}
index p = \ case
Fin 1 -> _𝕀ℝ3_x p
Fin 2 -> _𝕀ℝ3_y p
_ -> _𝕀ℝ3_z p
{-# INLINE index #-}
instance Representable 𝕀 ( 𝕀ℝ 4 ) where
tabulate f = 𝕀ℝ4 ( f ( Fin 1 ) ) ( f ( Fin 2 ) ) ( f ( Fin 3 ) ) ( f ( Fin 4 ) )
{-# INLINE tabulate #-}
index p = \ case
Fin 1 -> _𝕀ℝ4_x p
Fin 2 -> _𝕀ℝ4_y p
Fin 3 -> _𝕀ℝ4_z p
_ -> _𝕀ℝ4_w p
{-# INLINE index #-}

214
brush-strokes/src/lib/Math/Interval/Internal/FMA.hs Normal file
View file

@ -0,0 +1,214 @@
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Math.Interval.Internal.FMA
( 𝕀(..)
, scaleInterval
) where
-- base
import Prelude hiding ( Num(..), Fractional(..), Floating(..) )
import qualified Prelude
import GHC.Exts
( Double(D#), fmsubDouble#, fnmaddDouble# )
-- brush-strokes
import Math.Float.Utils
( prevFP, succFP )
import Math.Ring
-- deepseq
import Control.DeepSeq
( NFData(..) )
-- rounded-hw
import Numeric.Rounded.Hardware
( Rounded(..) )
import qualified Numeric.Rounded.Hardware.Interval.NonEmpty as Interval
( Interval(..) )
--------------------------------------------------------------------------------
{-# INLINE withError #-}
withError :: Double -> Double -> ( Double, Double )
withError f e =
case compare e 0 of
LT -> ( prevFP f, f )
EQ -> ( f, f )
GT -> ( f, succFP f )
addI :: Double -> Double -> ( Double, Double )
addI a b =
let !s = a + b
!a' = s - b
!b' = s - a'
!da = a - a'
!db = b - b'
!e = da + db
in s `withError` e
subI :: Double -> Double -> ( Double, Double )
subI a b =
let !s = a - b
!a' = s - b
!b' = s - a'
!da = a - a'
!db = b - b'
!e = da + db
in s `withError` e
{-# INLINE fmsubDouble #-}
fmsubDouble :: Double -> Double -> Double -> Double
fmsubDouble ( D# x ) ( D# y ) ( D# z ) = D# ( fmsubDouble# x y z )
{-# INLINE fnmaddDouble #-}
fnmaddDouble :: Double -> Double -> Double -> Double
fnmaddDouble ( D# x ) ( D# y ) ( D# z ) = D# ( fnmaddDouble# x y z )
prodI :: Double -> Double -> ( Double, Double )
prodI a b =
let !p = a * b
!e = fmsubDouble a b p
in p `withError` e
divI :: Double -> Double -> ( Double, Double )
divI a b =
let !r = a / b
!e = fnmaddDouble r b a
in r `withError` e
-- | Power of a **non-negative** number to a natural power.
posPowI :: Double -- ^ Assumed to be non-negative!
-> Word -> ( Double, Double )
posPowI _ 0 = ( 1, 1 )
posPowI f 1 = ( f, f )
posPowI f 2 = prodI f f
posPowI f n
| even n
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
= ( fst $ posPowI f²_lo m, snd $ posPowI f²_hi m )
| otherwise
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
= ( fst $ posPowAcc f²_lo m f, snd $ posPowAcc f²_hi m f )
posPowAcc :: Double -> Word -> Double -> ( Double, Double )
posPowAcc f 1 x = prodI f x
posPowAcc f n x
| even n
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
= ( fst $ posPowAcc f²_lo m x, snd $ posPowAcc f²_hi m x )
| otherwise
, let m = n `quot` 2
( f²_lo, f²_hi ) = prodI f f
( y_lo, y_hi ) = prodI f x
= ( fst $ posPowAcc f²_lo m y_lo, snd $ posPowAcc f²_hi m y_hi )
--------------------------------------------------------------------------------
-- | A non-empty interval of real numbers (possibly unbounded).
data 𝕀 = 𝕀 { inf, sup :: !Double }
instance NFData 𝕀 where
rnf ( 𝕀 lo hi ) = rnf lo `seq` rnf hi
instance Prelude.Num 𝕀 where
𝕀 x_lo x_hi + 𝕀 y_lo y_hi
| let !z_lo = fst $ addI x_lo y_lo
!z_hi = snd $ addI x_hi y_hi
= 𝕀 z_lo z_hi
𝕀 x_lo x_hi - 𝕀 y_lo y_hi
| let !z_lo = fst $ subI x_lo y_hi
!z_hi = snd $ subI x_hi y_lo
= 𝕀 z_lo z_hi
negate (𝕀 lo hi) = 𝕀 (Prelude.negate hi) (Prelude.negate lo)
(*) = (*)
fromInteger i =
let !j = Prelude.fromInteger i
in 𝕀 j j
abs (𝕀 lo hi)
| 0 <= lo
= 𝕀 lo hi
| hi <= 0
= 𝕀 (Prelude.negate hi) (Prelude.negate lo)
| otherwise
= 𝕀 0 (max (Prelude.negate lo) hi)
signum _ = error "No implementation of signum for intervals"
instance Ring 𝕀 where
𝕀 lo1 hi1 * 𝕀 lo2 hi2
| let !( x_min, x_max ) = prodI lo1 lo2
!( y_min, y_max ) = prodI lo1 hi2
!( z_min, z_max ) = prodI hi1 lo2
!( w_min, w_max ) = prodI hi1 hi2
= 𝕀 ( min ( min x_min y_min ) ( min z_min w_min ) )
( max ( max x_max y_max ) ( max z_max w_max ) )
_ ^ 0 = 𝕀 1 1
iv ^ 1 = iv
𝕀 lo hi ^ n
| odd n || 0 <= lo
, let !lo' = fst $ posPowI lo n
!hi' = snd $ posPowI hi n
= 𝕀 lo' hi'
| hi <= 0
, let !lo' = fst $ posPowI (negate hi) n
!hi' = snd $ posPowI (negate lo) n
= 𝕀 lo' hi'
| otherwise
, let !hi1 = snd $ posPowI (negate lo) n
, let !hi2 = snd $ posPowI hi n
= 𝕀 0 ( max hi1 hi2 )
instance Prelude.Fractional 𝕀 where
fromRational r =
let q = Prelude.fromRational r
in 𝕀 q q
recip ( 𝕀 lo hi )
-- #ifdef ASSERTS
| lo == 0
= 𝕀 ( fst $ divI 1 hi ) ( 1 Prelude./ 0 )
| hi == 0
= 𝕀 ( -1 Prelude./ 0 ) ( snd $ divI 1 lo )
| lo > 0 || hi < 0
-- #endif
= 𝕀 ( fst $ divI 1 hi ) ( snd $ divI 1 lo )
-- #ifdef ASSERTS
| otherwise
= error "BAD interval recip; should use extendedRecip instead"
-- #endif
p / q = p * Prelude.recip q
instance Floating 𝕀 where
sqrt = withHW Prelude.sqrt
instance Transcendental 𝕀 where
pi = 𝕀 3.141592653589793 3.1415926535897936
cos = withHW Prelude.cos
sin = withHW Prelude.sin
atan = withHW Prelude.atan
deriving via ViaPrelude 𝕀
instance AbelianGroup 𝕀
deriving via ViaPrelude 𝕀
instance Field 𝕀
{-# INLINE withHW #-}
-- | Internal function: use @rounded-hw@ to define a function on intervals.
withHW :: (Interval.Interval Double -> Interval.Interval Double) -> 𝕀 -> 𝕀
withHW f = \ ( 𝕀 lo hi ) ->
case f ( Interval.I ( Rounded lo ) ( Rounded hi ) ) of
Interval.I ( Rounded x ) ( Rounded y ) -> 𝕀 x y
-- | The width of an interval.
--
-- NB: assumes the endpoints are neither @NaN@ nor infinity.
width :: 𝕀 -> Double
width ( 𝕀 lo hi ) = hi - lo
scaleInterval :: Double -> 𝕀 -> 𝕀
scaleInterval s ( 𝕀 lo hi ) =
case compare s 0 of
LT -> 𝕀 ( fst $ prodI s hi ) ( snd $ prodI s lo )
EQ -> 𝕀 0 0
GT -> 𝕀 ( fst $ prodI s lo ) ( snd $ prodI s hi )

53
brush-strokes/src/lib/Math/Interval/Internal/RoundedHW.hs Normal file
View file

@ -0,0 +1,53 @@
module Math.Interval.Internal.RoundedHW
( 𝕀(𝕀, inf, sup)
, scaleInterval
)
where
-- base
import Prelude hiding ( Num(..), Fractional(..), Floating(..) )
import qualified Prelude
-- brush-strokes
import Math.Ring
-- deepseq
import Control.DeepSeq
( NFData(..) )
-- rounded-hw
import Numeric.Rounded.Hardware
( Rounded(..) )
import qualified Numeric.Rounded.Hardware.Interval.NonEmpty as Interval
( Interval(..), powInt )
--------------------------------------------------------------------------------
-- | A non-empty interval of real numbers (possibly unbounded).
newtype 𝕀 = MkI { ival :: Interval.Interval Double }
deriving newtype ( Prelude.Num, Prelude.Fractional, Prelude.Floating )
deriving newtype NFData
{-# COMPLETE 𝕀 #-}
pattern 𝕀 :: Double -> Double -> 𝕀
pattern 𝕀 { inf, sup } = MkI ( Interval.I ( Rounded inf ) ( Rounded sup ) )
instance Ring 𝕀 where
MkI i1 * MkI i2 = MkI $ i1 Prelude.* i2
MkI x ^ n = MkI { ival = Interval.powInt x ( Prelude.fromIntegral n ) }
-- This is very important, as x^2 is not the same as x * x
-- in interval arithmetic. This ensures we don't
-- accidentally use (^) from Prelude.
deriving via ViaPrelude 𝕀
instance AbelianGroup 𝕀
deriving via ViaPrelude 𝕀
instance Field 𝕀
deriving via ViaPrelude 𝕀
instance Floating 𝕀
deriving via ViaPrelude 𝕀
instance Transcendental 𝕀
scaleInterval :: Double -> 𝕀 -> 𝕀
scaleInterval s iv = 𝕀 s s * iv -- TODO: could be better

173
brush-strokes/src/lib/Math/Interval/Internal/SIMD.hs Normal file
View file

@ -0,0 +1,173 @@
{-# LANGUAGE CPP #-}
module Math.Interval.Internal.SIMD
( 𝕀(𝕀, inf, sup)
, scaleInterval
)
where
-- base
import Prelude hiding ( Num(..), Fractional(..), Floating(..) )
import qualified Prelude
import GHC.Exts
( isTrue#
, Double(D#), Double#
, (<=##), (*##), negateDouble#
, DoubleX2#
, packDoubleX2#, unpackDoubleX2#
, broadcastDoubleX2#
, plusDoubleX2#, timesDoubleX2#
)
-- ghc-prim
import GHC.Prim
( maxDouble#, shuffleDoubleX2# )
-- deepseq
import Control.DeepSeq
( NFData(..) )
-- rounded-hw
import Numeric.Rounded.Hardware
( Rounded(..) )
import qualified Numeric.Rounded.Hardware.Interval.NonEmpty as Interval
( Interval(..) )
-- brush-strokes
import Math.Ring
--------------------------------------------------------------------------------
-- | A non-empty interval of real numbers (possibly unbounded).
data 𝕀 = MkI DoubleX2#
-- Interval [lo..hi] represented as (hi, -lo)
instance NFData 𝕀 where
rnf ( MkI !_ ) = ()
{-# COMPLETE PackI #-}
pattern PackI :: Double# -> Double# -> 𝕀
pattern PackI hi m_lo <- ( ( \ ( MkI x ) -> unpackDoubleX2# x ) -> (# hi, m_lo #) )
where
PackI hi m_lo = MkI ( packDoubleX2# (# hi, m_lo #) )
{-# COMPLETE 𝕀 #-}
pattern 𝕀 :: Double -> Double -> 𝕀
pattern 𝕀 { inf, sup } <- ( ( \ ( PackI hi m_lo ) -> (# D# ( negateDouble# m_lo ), D# hi #) )
-> (# inf, sup #) )
where
𝕀 (D# lo) (D# hi) =
let m_lo = negateDouble# lo
in PackI hi m_lo
deriving via ViaPrelude 𝕀
instance AbelianGroup 𝕀
deriving via ViaPrelude 𝕀
instance Field 𝕀
instance Prelude.Num 𝕀 where
MkI x + MkI y = MkI ( x `plusDoubleX2#` y )
negate ( MkI x ) = MkI ( shuffleDoubleX2# x x (# 1#, 0# #) )
(*) = (*)
fromInteger i =
let !j = Prelude.fromInteger i
in 𝕀 j j
abs x@(PackI hi m_lo)
| D# m_lo <= 0
= PackI hi m_lo
| D# hi <= 0
= Prelude.negate x
| otherwise
= 𝕀 0 (max (D# m_lo) (D# hi))
signum _ = error "No implementation of signum for intervals"
instance Ring 𝕀 where
( PackI b ma ) * ( PackI d mc ) =
case ( zeroPos b ma, zeroPos d mc ) of
-- From "Fast and Correct SIMD Algorithms for Interval Arithmetic"
-- Frédéric Goualard, 2008
( LT, LT ) -> PackI (ma *## mc) ( ( negateDouble# b ) *## d)
( LT, EQ ) -> PackI (ma *## mc) ( ma *## d )
( LT, GT ) -> PackI ( b *## ( negateDouble# mc ) ) ( ma *## d )
( EQ, LT ) -> PackI (ma *## mc) ( b *## mc )
( EQ, EQ ) -> PackI
( maxDouble# ( ma *## d ) ( b *## mc ) )
( maxDouble# ( ma *## mc ) ( b *## d ) )
( EQ, GT ) -> PackI ( b *## d ) ( ma *## d )
( GT, LT ) -> PackI ( ( negateDouble# ma ) *## d ) ( b *## mc )
( GT, EQ ) -> PackI ( b *## d ) ( b *## mc )
( GT, GT ) -> PackI ( b *## d ) ( ( negateDouble# ma ) *## mc )
where
zeroPos :: Double# -> Double# -> Ordering
zeroPos hi m_lo
| isTrue# (hi <=## 0.0##)
= LT
| isTrue# (m_lo <=## 0.0##)
= GT
| otherwise
= EQ
iv ^ 1 = iv
PackI hi m_lo ^ n
| odd n || isTrue# (m_lo <=## 0.0##)
, let !(D# m_lo') = D# m_lo Prelude.^ n
!(D# hi' ) = D# hi Prelude.^ n
= PackI hi' m_lo'
| isTrue# (hi <=## 0.0##)
, let !(D# m_lo') = (D# hi ) Prelude.^ n
!(D# hi') = (D# m_lo) Prelude.^ n
= PackI hi' m_lo'
| otherwise
, let !(D# hi1) = (D# m_lo) Prelude.^ n
!(D# hi2) = (D# hi ) Prelude.^ n
hi' = maxDouble# hi1 hi2
= PackI hi' 0.0##
instance Prelude.Fractional 𝕀 where
fromRational r =
let q = Prelude.fromRational r
in 𝕀 q q
recip ( 𝕀 lo hi )
#ifdef ASSERTS
| lo == 0
= 𝕀 ( Prelude.recip hi ) ( 1 Prelude./ 0 )
| hi == 0
= 𝕀 ( -1 Prelude./ 0 ) ( Prelude.recip lo )
| lo > 0 || hi < 0
#endif
= 𝕀 ( Prelude.recip hi ) ( Prelude.recip lo )
#ifdef ASSERTS
| otherwise
= error "BAD interval recip; should use extendedRecip instead"
#endif
p / q = p * Prelude.recip q
instance Floating 𝕀 where
sqrt = withHW Prelude.sqrt
instance Transcendental 𝕀 where
pi = 𝕀 3.141592653589793 3.1415926535897936
cos = withHW Prelude.cos
sin = withHW Prelude.sin
atan = withHW Prelude.atan
{-# INLINE withHW #-}
-- | Internal function: use @rounded-hw@ to define a function on intervals.
withHW :: (Interval.Interval Double -> Interval.Interval Double) -> 𝕀 -> 𝕀
withHW f = \ ( 𝕀 lo hi ) ->
case f ( Interval.I ( Rounded lo ) ( Rounded hi ) ) of
Interval.I ( Rounded x ) ( Rounded y ) -> 𝕀 x y
scaleInterval :: Double -> 𝕀 -> 𝕀
scaleInterval s@(D# s#) i =
case compare s 0 of
LT -> case negate i of { MkI x -> MkI ( broadcastDoubleX2# ( negateDouble# s# ) `timesDoubleX2#` x ) }
EQ -> 𝕀 0 0
GT -> case i of { MkI x -> MkI ( broadcastDoubleX2# s# `timesDoubleX2#` x ) }
{-
TODO: consider using https://github.com/JishinMaster/simd_utils/blob/160c50f07e08d2077ae4368f0aed2f10f7173c67/simd_utils_sse_double.h#L530
for sin/cos? Or Intel SVML? Or metalibm?
-}

2
brush-strokes/src/lib/Math/Root/Isolation.hs
View file

@ -204,7 +204,7 @@ isolateRootsIn ( RootIsolationOptions { rootIsolationAlgorithms } )
[ RootIsolationTree ( Box n ) ] [ RootIsolationTree ( Box n ) ]
go history cand go history cand
| -- Check the range of the equations contains zero. | -- Check the range of the equations contains zero.
not $ ( unT ( origin @Double ) ∈ iRange ) not $ ( all ( unT ( origin @Double ) ∈ ) $ coordinates iRange )
-- Box doesn't contain a solution: discard it. -- Box doesn't contain a solution: discard it.
= return [ RootIsolationLeaf "rangeTest" cand ] = return [ RootIsolationLeaf "rangeTest" cand ]
| otherwise | otherwise

32
brush-strokes/src/lib/Math/Root/Isolation/Bisection.hs
View file

@ -120,7 +120,7 @@ defaultBisectionOptions minWidth _ε_eq box =
-- box(0)-consistency -- box(0)-consistency
let iRange' :: Box d let iRange' :: Box d
iRange' = eqs box' `monIndex` zeroMonomial iRange' = eqs box' `monIndex` zeroMonomial
in unT ( origin @Double ) ∈ iRange' in all ( unT ( origin @Double ) ∈ ) ( coordinates iRange' )
-- box(1)-consistency -- box(1)-consistency
--let box1Options = Box1Options _ε_eq ( toList $ universe @n ) ( toList $ universe @d ) --let box1Options = Box1Options _ε_eq ( toList $ universe @n ) ( toList $ universe @d )
@ -173,33 +173,33 @@ type CoordBisectionData :: Nat -> Nat -> Type -> Type
data CoordBisectionData n d r = data CoordBisectionData n d r =
CoordBisectionData CoordBisectionData
{ coordIndex :: !( Fin n ) { coordIndex :: !( Fin n )
, coordInterval :: !( 𝕀 Double ) , coordInterval :: !𝕀
, coordJacobianColumn :: !( 𝕀ℝ d ) , coordJacobianColumn :: !( 𝕀ℝ d )
, coordBisectionData :: !r , coordBisectionData :: !r
} }
deriving stock instance ( Show ( ℝ d ), Show r ) deriving stock instance ( Show ( 𝕀ℝ d ), Show r )
=> Show ( CoordBisectionData n d r ) => Show ( CoordBisectionData n d r )
spread :: ( BoxCt n d, Representable Double ( ℝ d ) ) spread :: ( BoxCt n d, Representable 𝕀 ( 𝕀ℝ d ) )
=> CoordBisectionData n d r -> Double => CoordBisectionData n d r -> Double
spread ( CoordBisectionData { coordInterval = cd, coordJacobianColumn = j_cd } ) spread ( CoordBisectionData { coordInterval = cd, coordJacobianColumn = j_cd } )
= width cd * normVI j_cd = width cd * normVI j_cd
{-# INLINEABLE spread #-} {-# INLINEABLE spread #-}
normVI :: ( Applicative ( Vec d ), Representable Double ( ℝ d ) ) => 𝕀ℝ d -> Double normVI :: ( Applicative ( Vec d ), Representable 𝕀 ( 𝕀ℝ d ) ) => 𝕀ℝ d -> Double
normVI ( 𝕀 los his ) = normVI box =
sqrt $ sum ( nm1 <$> coordinates los <*> coordinates his ) sqrt $ sum ( nm1 <$> coordinates box )
where where
nm1 :: Double -> Double -> Double nm1 :: 𝕀 -> Double
nm1 lo hi = max ( abs lo ) ( abs hi ) Ring.^ 2 nm1 ( 𝕀 lo hi ) = max ( abs lo ) ( abs hi ) Ring.^ 2
{-# INLINEABLE normVI #-} {-# INLINEABLE normVI #-}
maxVI :: ( Applicative ( Vec d ), Representable Double ( ℝ d ) ) => 𝕀ℝ d -> Double maxVI :: ( Applicative ( Vec d ), Representable 𝕀 ( 𝕀ℝ d ) ) => 𝕀ℝ d -> Double
maxVI ( 𝕀 los his ) = maxVI box =
maximum ( maxAbs <$> coordinates los <*> coordinates his ) maximum ( maxAbs <$> coordinates box )
where where
maxAbs :: Double -> Double -> Double maxAbs :: 𝕀 -> Double
maxAbs lo hi = max ( abs lo ) ( abs hi ) maxAbs ( 𝕀 lo hi ) = max ( abs lo ) ( abs hi )
{-# INLINEABLE maxVI #-} {-# INLINEABLE maxVI #-}
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
@ -210,7 +210,7 @@ maxVI ( 𝕀 los his ) =
-- dimension to bisect.) -- dimension to bisect.)
bisection bisection
:: forall n :: forall n
. ( 1 <= n, KnownNat n, Representable Double ( ℝ n ) ) . ( 1 <= n, KnownNat n, Representable 𝕀 ( 𝕀ℝ n ) )
=> ( Box n -> Bool ) => ( Box n -> Bool )
-- ^ how to check whether a box contains solutions -- ^ how to check whether a box contains solutions
-> ( forall r. NE.NonEmpty ( Fin n, r ) -> ( r, String ) ) -> ( forall r. NE.NonEmpty ( Fin n, r ) -> ( r, String ) )
@ -250,7 +250,7 @@ bisection canHaveSols pickFallbackBisCoord box =
-- | Bisect a box in the given coordinate dimension. -- | Bisect a box in the given coordinate dimension.
bisectInCoord bisectInCoord
:: Representable Double ( ℝ n ) :: Representable 𝕀 ( 𝕀ℝ n )
=> Box n -> Fin n -> ( Double, NE.NonEmpty ( Box n ) ) => Box n -> Fin n -> ( Double, NE.NonEmpty ( Box n ) )
bisectInCoord box i = bisectInCoord box i =
let z = box `index` i let z = box `index` i

14
brush-strokes/src/lib/Math/Root/Isolation/Core.hs
View file

@ -97,17 +97,21 @@ type BoxCt n d =
, Show ( 𝕀ℝ n ), Show ( ℝ n ) , Show ( 𝕀ℝ n ), Show ( ℝ n )
, Eq ( ℝ n ) , Eq ( ℝ n )
, Representable Double ( ℝ n ) , Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, MonomialBasis ( D 1 ( ℝ n ) ) , MonomialBasis ( D 1 ( ℝ n ) )
, Deg ( D 1 ( ℝ n ) ) ~ 1 , Deg ( D 1 ( ℝ n ) ) ~ 1
, Vars ( D 1 ( ℝ n ) ) ~ n , Vars ( D 1 ( ℝ n ) ) ~ n
, Module Double ( T ( ℝ n ) ) , Module Double ( T ( ℝ n ) )
, Module ( 𝕀 Double ) ( T ( 𝕀ℝ n ) ) , Module 𝕀 ( T ( 𝕀ℝ n ) )
, NFData ( ℝ n )
, NFData ( 𝕀ℝ n ) , NFData ( 𝕀ℝ n )
, Ord ( ℝ d ) , Ord ( ℝ d )
, Module Double ( T ( ℝ d ) ) , Module Double ( T ( ℝ d ) )
, Representable Double ( ℝ d ) , Representable Double ( ℝ d )
, Representable 𝕀 ( 𝕀ℝ d )
, NFData ( ℝ d ) , NFData ( ℝ d )
, NFData ( 𝕀ℝ d )
) )
-- | Boxes we are done with and will not continue processing. -- | Boxes we are done with and will not continue processing.
data DoneBoxes n = data DoneBoxes n =
@ -235,15 +239,15 @@ data RootIsolationTree d
| RootIsolationStep RootIsolationStep [ ( d, RootIsolationTree d ) ] | RootIsolationStep RootIsolationStep [ ( d, RootIsolationTree d ) ]
showRootIsolationTree showRootIsolationTree
:: ( Representable Double ( ℝ n ), Show ( Box n ) ) :: ( Representable 𝕀 ( 𝕀ℝ n ), Show ( Box n ) )
=> Box n -> RootIsolationTree ( Box n ) -> Tree String => Box n -> RootIsolationTree ( Box n ) -> Tree String
showRootIsolationTree cand (RootIsolationLeaf why l) = Node (show cand ++ " " ++ showArea (boxArea cand) ++ " " ++ why ++ " " ++ show l) [] showRootIsolationTree cand (RootIsolationLeaf why l) = Node (show cand ++ " " ++ showArea (boxArea cand) ++ " " ++ why ++ " " ++ show l) []
showRootIsolationTree cand (RootIsolationStep s ts) showRootIsolationTree cand (RootIsolationStep s ts)
= Node (show cand ++ " abc " ++ showArea (boxArea cand) ++ " " ++ show s) $ map (\ (c,t) -> showRootIsolationTree c t) ts = Node (show cand ++ " abc " ++ showArea (boxArea cand) ++ " " ++ show s) $ map (\ (c,t) -> showRootIsolationTree c t) ts
boxArea :: Representable Double ( ℝ n ) => Box n -> Double {-# INLINEABLE boxArea #-}
boxArea ( 𝕀 lo hi ) = boxArea :: Representable 𝕀 ( 𝕀ℝ n ) => Box n -> Double
product ( ( \ l h -> abs ( h - l ) ) <$> coordinates lo <*> coordinates hi ) boxArea box = product ( width <$> coordinates box )
showArea :: Double -> String showArea :: Double -> String
showArea area = "(area " ++ showFFloat (Just 6) area "" ++ ")" showArea area = "(area " ++ showFFloat (Just 6) area "" ++ ")"

20
brush-strokes/src/lib/Math/Root/Isolation/Degree.hs
View file

@ -31,14 +31,14 @@ topologicalDegree
-> 𝕀ℝ 2 -> 𝕀ℝ 2
-- ^ box -- ^ box
-> Maybe Int -> Maybe Int
topologicalDegree ε_bis f ( 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_hi y_hi ) ) = topologicalDegree ε_bis f ( 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_lo y_hi ) ) =
topologicalDegreeFromContour $ topologicalDegreeFromContour $
smallArrayFromList $ smallArrayFromList $
concatMap ( tagFacet ε_bis f ) concatMap ( tagFacet ε_bis f )
[ ( Tag ( Fin 2 ) P, 𝕀 ( ℝ2 x_hi y_lo ) ( ℝ2 x_hi y_hi ) ) [ ( Tag ( Fin 2 ) P, 𝕀ℝ2 ( 𝕀 x_hi x_hi ) ( 𝕀 y_lo y_hi ) )
, ( Tag ( Fin 1 ) N, 𝕀 ( ℝ2 x_lo y_hi ) ( ℝ2 x_hi y_hi ) ) , ( Tag ( Fin 1 ) N, 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_hi y_hi ) )
, ( Tag ( Fin 2 ) N, 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_lo y_hi ) ) , ( Tag ( Fin 2 ) N, 𝕀ℝ2 ( 𝕀 x_lo x_lo ) ( 𝕀 y_lo y_hi ) )
, ( Tag ( Fin 1 ) P, 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_hi y_lo ) ) ] , ( Tag ( Fin 1 ) P, 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_lo y_lo ) ) ]
-- | Tag a facet with the sign of one of the equations that is non-zero -- | Tag a facet with the sign of one of the equations that is non-zero
-- on that facet. -- on that facet.
@ -77,11 +77,13 @@ bisectFacet ( Tag i s ) x =
bisectFacet NoTag _ = error "impossible: input always tagged" bisectFacet NoTag _ = error "impossible: input always tagged"
bisectInCoord :: Fin n -> 𝕀ℝ 2 -> [ 𝕀ℝ 2 ] bisectInCoord :: Fin n -> 𝕀ℝ 2 -> [ 𝕀ℝ 2 ]
bisectInCoord ( Fin 1 ) ( 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_hi y_hi ) ) = bisectInCoord ( Fin 1 ) ( 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_lo y_hi ) ) =
[ 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_mid y_hi ), 𝕀 ( ℝ2 x_mid y_lo ) ( ℝ2 x_hi y_hi ) ] [ 𝕀ℝ2 ( 𝕀 x_lo x_mid ) ( 𝕀 y_lo y_hi )
, 𝕀ℝ2 ( 𝕀 x_mid x_hi ) ( 𝕀 y_lo y_hi ) ]
where x_mid = 0.5 * ( x_lo + x_hi ) where x_mid = 0.5 * ( x_lo + x_hi )
bisectInCoord _ ( 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_hi y_hi ) ) = bisectInCoord _ ( 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_lo y_hi ) ) =
[ 𝕀 ( ℝ2 x_lo y_lo ) ( ℝ2 x_hi y_mid ), 𝕀 ( ℝ2 x_lo y_mid ) ( ℝ2 x_hi y_hi ) ] [ 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_lo y_mid )
, 𝕀ℝ2 ( 𝕀 x_lo x_hi ) ( 𝕀 y_mid y_hi ) ]
where y_mid = 0.5 * ( y_lo + y_hi ) where y_mid = 0.5 * ( y_lo + y_hi )
-- | Compute the topological degree of \( f \colon \mathbb{IR}^n \to \mathbb{IR}^n \) -- | Compute the topological degree of \( f \colon \mathbb{IR}^n \to \mathbb{IR}^n \)

49
brush-strokes/src/lib/Math/Root/Isolation/Narrowing.hs
View file

@ -156,11 +156,14 @@ defaultBox2Options minWidth ε_eq =
-- See also -- See also
-- "Presentation of a highly tuned multithreaded interval solver for underdetermined and well-determined nonlinear systems" -- "Presentation of a highly tuned multithreaded interval solver for underdetermined and well-determined nonlinear systems"
makeBox1Consistent makeBox1Consistent
:: ( KnownNat n, Representable Double ( ℝ n ) :: ( KnownNat n
, Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, MonomialBasis ( D 1 ( ℝ n ) ) , MonomialBasis ( D 1 ( ℝ n ) )
, Deg ( D 1 ( ℝ n ) ) ~ 1 , Deg ( D 1 ( ℝ n ) ) ~ 1
, Vars ( D 1 ( ℝ n ) ) ~ n , Vars ( D 1 ( ℝ n ) ) ~ n
, Representable Double ( ℝ d ) , Representable Double ( ℝ d )
, Representable 𝕀 ( 𝕀ℝ d )
) )
=> Box1Options n d => Box1Options n d
-> ( 𝕀ℝ n -> D 1 ( 𝕀ℝ n ) ( 𝕀ℝ d ) ) -> ( 𝕀ℝ n -> D 1 ( 𝕀ℝ n ) ( 𝕀ℝ d ) )
@ -174,11 +177,14 @@ makeBox1Consistent box1Options eqs x =
-- "Parallelization of a bound-consistency enforcing procedure and its application in solving nonlinear systems" -- "Parallelization of a bound-consistency enforcing procedure and its application in solving nonlinear systems"
makeBox2Consistent makeBox2Consistent
:: forall n d :: forall n d
. ( KnownNat n, Representable Double ( ℝ n ) . ( KnownNat n
, Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, MonomialBasis ( D 1 ( ℝ n ) ) , MonomialBasis ( D 1 ( ℝ n ) )
, Deg ( D 1 ( ℝ n ) ) ~ 1 , Deg ( D 1 ( ℝ n ) ) ~ 1
, Vars ( D 1 ( ℝ n ) ) ~ n , Vars ( D 1 ( ℝ n ) ) ~ n
, Representable Double ( ℝ d ) , Representable Double ( ℝ d )
, Representable 𝕀 ( 𝕀ℝ d )
) )
=> Box2Options n d => Box2Options n d
-> ( 𝕀ℝ n -> D 1 ( 𝕀ℝ n ) ( 𝕀ℝ d ) ) -> ( 𝕀ℝ n -> D 1 ( 𝕀ℝ n ) ( 𝕀ℝ d ) )
@ -240,7 +246,7 @@ data NarrowingMethod
narrowingMethods narrowingMethods
:: Double -> Double :: Double -> Double
-> NarrowingMethod -> NarrowingMethod
-> [ ( 𝕀 Double -> ( 𝕀 Double, 𝕀 Double ) ) -> 𝕀 Double -> [ 𝕀 Double ] ] -> [ ( 𝕀 -> ( 𝕀, 𝕀 ) ) -> 𝕀 -> [ 𝕀 ] ]
narrowingMethods ε_eq ε_bis Kubica narrowingMethods ε_eq ε_bis Kubica
= [ leftNarrow ε_eq ε_bis, rightNarrow ε_eq ε_bis ] = [ leftNarrow ε_eq ε_bis, rightNarrow ε_eq ε_bis ]
narrowingMethods ε_eq ε_bis ( AdaptiveShaving opts ) narrowingMethods ε_eq ε_bis ( AdaptiveShaving opts )
@ -252,11 +258,14 @@ narrowingMethods _ε_eq ε_bis TwoSidedShaving
allNarrowingOperators allNarrowingOperators
:: forall n d :: forall n d
. ( KnownNat n, Representable Double ( ℝ n ) . ( KnownNat n
, Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, MonomialBasis ( D 1 ( ℝ n ) ) , MonomialBasis ( D 1 ( ℝ n ) )
, Deg ( D 1 ( ℝ n ) ) ~ 1 , Deg ( D 1 ( ℝ n ) ) ~ 1
, Vars ( D 1 ( ℝ n ) ) ~ n , Vars ( D 1 ( ℝ n ) ) ~ n
, Representable Double ( ℝ d ) , Representable Double ( ℝ d )
, Representable 𝕀 ( 𝕀ℝ d )
) )
=> Box1Options n d => Box1Options n d
-> ( 𝕀ℝ n -> D 1 ( 𝕀ℝ n ) ( 𝕀ℝ d ) ) -> ( 𝕀ℝ n -> D 1 ( 𝕀ℝ n ) ( 𝕀ℝ d ) )
@ -281,7 +290,7 @@ allNarrowingOperators ( Box1Options ε_eq ε_bis coordsToNarrow eqsToUse narrowi
, eqnIndex <- eqsToUse , eqnIndex <- eqsToUse
] ]
where where
ff' :: Fin n -> Fin d -> 𝕀ℝ n -> ( 𝕀 Double, 𝕀 Double ) ff' :: Fin n -> Fin d -> 𝕀ℝ n -> ( 𝕀, 𝕀 )
ff' i d ts = ff' i d ts =
let df = eqs ts let df = eqs ts
f, f' :: 𝕀ℝ d f, f' :: 𝕀ℝ d
@ -301,9 +310,9 @@ allNarrowingOperators ( Box1Options ε_eq ε_bis coordsToNarrow eqsToUse narrowi
-- by Bartłomiej Jacek Kubica, 2017 -- by Bartłomiej Jacek Kubica, 2017
leftNarrow :: Double leftNarrow :: Double
-> Double -> Double
-> ( 𝕀 Double -> ( 𝕀 Double, 𝕀 Double ) ) -> ( 𝕀 -> ( 𝕀, 𝕀 ) )
-> 𝕀 Double -> 𝕀
-> [ 𝕀 Double ] -> [ 𝕀 ]
leftNarrow ε_eq ε_bis ff' = left_narrow leftNarrow ε_eq ε_bis ff' = left_narrow
where where
left_narrow ( 𝕀 x_inf x_sup ) = left_narrow ( 𝕀 x_inf x_sup ) =
@ -334,9 +343,9 @@ leftNarrow ε_eq ε_bis ff' = left_narrow
-- TODO: de-duplicate with 'leftNarrow'? -- TODO: de-duplicate with 'leftNarrow'?
rightNarrow :: Double rightNarrow :: Double
-> Double -> Double
-> ( 𝕀 Double -> ( 𝕀 Double, 𝕀 Double ) ) -> ( 𝕀 -> ( 𝕀, 𝕀 ) )
-> 𝕀 Double -> 𝕀
-> [ 𝕀 Double ] -> [ 𝕀 ]
rightNarrow ε_eq ε_bis ff' = right_narrow rightNarrow ε_eq ε_bis ff' = right_narrow
where where
right_narrow ( 𝕀 x_inf x_sup ) = right_narrow ( 𝕀 x_inf x_sup ) =
@ -388,23 +397,23 @@ defaultAdaptiveShavingOptions =
leftShave :: Double leftShave :: Double
-> Double -> Double
-> AdaptiveShavingOptions -> AdaptiveShavingOptions
-> ( 𝕀 Double -> ( 𝕀 Double, 𝕀 Double ) ) -> ( 𝕀 -> ( 𝕀, 𝕀 ) )
-> 𝕀 Double -> 𝕀
-> [ 𝕀 Double ] -> [ 𝕀 ]
leftShave ε_eq ε_bis leftShave ε_eq ε_bis
( AdaptiveShavingOptions { γ_init, σ_good, σ_bad, β_good, β_bad } ) ( AdaptiveShavingOptions { γ_init, σ_good, σ_bad, β_good, β_bad } )
ff' i0 = ff' i0 =
left_narrow γ_init i0 left_narrow γ_init i0
where where
w0 = width i0 w0 = width i0
left_narrow :: Double -> 𝕀 Double -> [ 𝕀 Double ] left_narrow :: Double -> 𝕀 -> [ 𝕀 ]
left_narrow γ i@( 𝕀 x_inf x_sup ) left_narrow γ i@( 𝕀 x_inf x_sup )
-- Stop if the box is too small. -- Stop if the box is too small.
| width i < ε_bis | width i < ε_bis
= [ i ] = [ i ]
| otherwise | otherwise
= go γ x_sup ( 𝕀 x_inf ( if x_inf == x_sup then x_inf else succFP x_inf ) ) = go γ x_sup ( 𝕀 x_inf ( if x_inf == x_sup then x_inf else succFP x_inf ) )
go :: Double -> Double -> 𝕀 Double -> [ 𝕀 Double ] go :: Double -> Double -> 𝕀 -> [ 𝕀 ]
go γ x_sup x_left = go γ x_sup x_left =
let ( f_x_left, _f'_x_left ) = ff' x_left let ( f_x_left, _f'_x_left ) = ff' x_left
in in
@ -429,7 +438,7 @@ leftShave ε_eq ε_bis
-- Do a Newton step to try to reduce the guess interval. -- Do a Newton step to try to reduce the guess interval.
-- Starting from "guess", we get a collection of sub-intervals -- Starting from "guess", we get a collection of sub-intervals
-- "guesses'" refining where the function can be zero. -- "guesses'" refining where the function can be zero.
let guesses' :: [ ( 𝕀 Double ) ] let guesses' :: [ 𝕀 ]
guesses' = do guesses' = do
δ <- f_x_left ⊘ f'_guess δ <- f_x_left ⊘ f'_guess
let guess' = singleton ( inf guess ) - δ let guess' = singleton ( inf guess ) - δ
@ -463,11 +472,11 @@ leftShave ε_eq ε_bis
-- "A Data-Parallel Algorithm to Reliably Solve Systems of Nonlinear Equations", -- "A Data-Parallel Algorithm to Reliably Solve Systems of Nonlinear Equations",
-- (Frédéric Goualard, Alexandre Goldsztejn, 2008). -- (Frédéric Goualard, Alexandre Goldsztejn, 2008).
sbc :: Double sbc :: Double
-> ( 𝕀 Double -> ( 𝕀 Double, 𝕀 Double ) ) -> ( 𝕀 -> ( 𝕀, 𝕀 ) )
-> 𝕀 Double -> [ 𝕀 Double ] -> 𝕀 -> [ 𝕀 ]
sbc ε ff' = go sbc ε ff' = go
where where
go :: 𝕀 Double -> [ 𝕀 Double ] go :: 𝕀 -> [ 𝕀 ]
go x@( 𝕀 x_l x_r ) go x@( 𝕀 x_l x_r )
| width x <= ε | width x <= ε
= [ x ] = [ x ]

10
brush-strokes/src/lib/Math/Root/Isolation/Newton.hs
View file

@ -86,6 +86,8 @@ defaultNewtonOptions
, 1 <= n, 1 <= d, n <= d , 1 <= n, 1 <= d, n <= d
, Representable Double ( ℝ n ) , Representable Double ( ℝ n )
, Representable Double ( ℝ d ) , Representable Double ( ℝ d )
, Representable 𝕀 ( 𝕀ℝ n )
, Representable 𝕀 ( 𝕀ℝ d )
) )
=> BoxHistory n => BoxHistory n
-> NewtonOptions n d -> NewtonOptions n d
@ -110,7 +112,7 @@ intervalNewton opts eqs x = case opts of
, gsPickEqs = pickEqs , gsPickEqs = pickEqs
, gsUpdate , gsUpdate
} ) -> } ) ->
let x_mid = singleton $ boxMidpoint x let x_mid = point $ boxMidpoint x
f :: 𝕀ℝ n -> 𝕀ℝ n f :: 𝕀ℝ n -> 𝕀ℝ n
f = \ x_0 -> pickEqs $ eqs x_0 `monIndex` zeroMonomial f = \ x_0 -> pickEqs $ eqs x_0 `monIndex` zeroMonomial
f'_x :: Vec n ( 𝕀ℝ n ) f'_x :: Vec n ( 𝕀ℝ n )
@ -123,7 +125,7 @@ intervalNewton opts eqs x = case opts of
-- Precondition the above linear system into A ( x - x_mid ) = B. -- Precondition the above linear system into A ( x - x_mid ) = B.
!( !a, !b ) = force $ !( !a, !b ) = force $
precondition precondMeth precondition precondMeth
f'_x ( singleton minus_f_x_mid ) f'_x ( point minus_f_x_mid )
!x'_0 = force ( T x ^-^ T x_mid ) !x'_0 = force ( T x ^-^ T x_mid )
-- NB: we have to change coordinates, putting the midpoint of the box -- NB: we have to change coordinates, putting the midpoint of the box
@ -144,14 +146,14 @@ intervalNewton opts eqs x = case opts of
return ( dt, todo ) return ( dt, todo )
NewtonLP -> NewtonLP ->
-- TODO: reduce duplication with the above. -- TODO: reduce duplication with the above.
let x_mid = singleton $ boxMidpoint x let x_mid = point $ boxMidpoint x
f :: 𝕀ℝ 2 -> 𝕀ℝ d f :: 𝕀ℝ 2 -> 𝕀ℝ d
f = \ x_0 -> eqs x_0 `monIndex` zeroMonomial f = \ x_0 -> eqs x_0 `monIndex` zeroMonomial
f'_x :: Vec 2 ( 𝕀ℝ d ) f'_x :: Vec 2 ( 𝕀ℝ d )
f'_x = fmap ( \ i -> eqs x `monIndex` linearMonomial i ) ( universe @2 ) f'_x = fmap ( \ i -> eqs x `monIndex` linearMonomial i ) ( universe @2 )
minus_f_x_mid = unT $ -1 *^ T ( boxMidpoint $ f x_mid ) minus_f_x_mid = unT $ -1 *^ T ( boxMidpoint $ f x_mid )
!( !a, !b ) = force ( f'_x, singleton minus_f_x_mid ) !( !a, !b ) = force ( f'_x, point minus_f_x_mid )
!x'_0 = force ( T x ^-^ T x_mid ) !x'_0 = force ( T x ^-^ T x_mid )
( x's, dt ) = ( x's, dt ) =
timeInterval timeInterval

23
brush-strokes/src/lib/Math/Root/Isolation/Newton/GaussSeidel.hs
View file

@ -68,8 +68,8 @@ defaultGaussSeidelOptions
:: forall n d :: forall n d
. ( KnownNat n, KnownNat d . ( KnownNat n, KnownNat d
, 1 <= n, 1 <= d, n <= d , 1 <= n, 1 <= d, n <= d
, Representable Double ( ℝ n ) , Representable Double ( ℝ n ), Representable 𝕀 ( 𝕀ℝ n )
, Representable Double ( ℝ d ) , Representable Double ( ℝ d ), Representable 𝕀 ( 𝕀ℝ d )
) )
=> BoxHistory n => BoxHistory n
-> GaussSeidelOptions n d -> GaussSeidelOptions n d
@ -102,7 +102,10 @@ data Preconditioner
-- refining the initial guess box for \( X \) into up to \( 2^n \) (disjoint) new boxes. -- refining the initial guess box for \( X \) into up to \( 2^n \) (disjoint) new boxes.
gaussSeidelUpdate gaussSeidelUpdate
:: forall n :: forall n
. ( Representable Double ( ℝ n ), n ~ RepDim ( ℝ n ), Eq ( ℝ n ) ) . ( Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, Eq ( ℝ n )
)
=> GaussSeidelUpdateMethod -- ^ which step method to use => GaussSeidelUpdateMethod -- ^ which step method to use
-> Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \) -> Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \)
-> 𝕀ℝ n -- ^ \( B \) -> 𝕀ℝ n -- ^ \( B \)
@ -120,7 +123,10 @@ gaussSeidelUpdate upd as b x =
-- The boolean indicates whether the Gauss–Seidel step was a contraction. -- The boolean indicates whether the Gauss–Seidel step was a contraction.
gaussSeidelStep gaussSeidelStep
:: forall n :: forall n
. ( Representable Double ( ℝ n ), n ~ RepDim ( ℝ n ), Eq ( ℝ n ) ) . ( Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
, Eq ( ℝ n )
)
=> Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \) => Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \)
-> 𝕀ℝ n -- ^ \( B \) -> 𝕀ℝ n -- ^ \( B \)
-> T ( 𝕀ℝ n ) -- ^ initial box \( X \) -> T ( 𝕀ℝ n ) -- ^ initial box \( X \)
@ -160,7 +166,9 @@ gaussSeidelStep as b ( T x0 ) = coerce $
-- (Montanher, Domes, Schichl, Neumaier) (2017) -- (Montanher, Domes, Schichl, Neumaier) (2017)
gaussSeidelStep_Complete gaussSeidelStep_Complete
:: forall n :: forall n
. ( Representable Double ( ℝ n ), n ~ RepDim ( ℝ n ) ) . ( Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
)
=> Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \) => Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \)
-> 𝕀ℝ n -- ^ \( B \) -> 𝕀ℝ n -- ^ \( B \)
-> T ( 𝕀ℝ n ) -- ^ initial box \( X \) -> T ( 𝕀ℝ n ) -- ^ initial box \( X \)
@ -193,7 +201,10 @@ gaussSeidelStep_Complete as b ( T x0 ) = coerce $ do
-- | Pre-condition the system \( AX = B \). -- | Pre-condition the system \( AX = B \).
precondition precondition
:: forall n :: forall n
. ( KnownNat n, Representable Double ( ℝ n ) ) . ( KnownNat n
, Representable Double ( ℝ n )
, Representable 𝕀 ( 𝕀ℝ n )
)
=> Preconditioner -- ^ pre-conditioning method to use => Preconditioner -- ^ pre-conditioning method to use
-> Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \) -> Vec n ( 𝕀ℝ n ) -- ^ columns of \( A \)
-> 𝕀ℝ n -- ^ \( B \) -> 𝕀ℝ n -- ^ \( B \)

18
brush-strokes/src/lib/Math/Root/Isolation/Newton/LP.hs
View file

@ -42,7 +42,7 @@ import Math.Linear
-- | Solve the system of linear equations \( A X = B \) -- | Solve the system of linear equations \( A X = B \)
-- using linear programming. -- using linear programming.
solveIntervalLinearEquations solveIntervalLinearEquations
:: ( KnownNat d, Representable Double ( ℝ d ) ) :: ( KnownNat d, Representable 𝕀 ( 𝕀ℝ d ) )
=> Vec 2 ( 𝕀ℝ d ) -- ^ columns of \( A \) => Vec 2 ( 𝕀ℝ d ) -- ^ columns of \( A \)
-> 𝕀ℝ d -- ^ \( B \) -> 𝕀ℝ d -- ^ \( B \)
-> T ( 𝕀ℝ 2 ) -- ^ initial box \( X \) -> T ( 𝕀ℝ 2 ) -- ^ initial box \( X \)
@ -61,18 +61,18 @@ solveIntervalLinearEquations a b x =
-- is in fact a strict subset. -- is in fact a strict subset.
isSubBox :: T ( 𝕀ℝ 2 ) -> T ( 𝕀ℝ 2 ) -> Bool isSubBox :: T ( 𝕀ℝ 2 ) -> T ( 𝕀ℝ 2 ) -> Bool
isSubBox isSubBox
( T ( 𝕀 ( ℝ2 x1_min y1_min ) ( ℝ2 x1_max y1_max ) ) ) ( T ( 𝕀ℝ2 ( 𝕀 x1_min x1_max ) ( 𝕀 y1_min y1_max ) ) )
( T ( 𝕀 ( ℝ2 x2_min y2_min ) ( ℝ2 x2_max y2_max ) ) ) ( T ( 𝕀ℝ2 ( 𝕀 x2_min x2_max ) ( 𝕀 y2_min y2_max ) ) )
= ( ( x2_min > x1_min && x2_max < x1_max ) || x2_min == x2_max ) = ( ( x2_min > x1_min && x2_max < x1_max ) || x2_min == x2_max )
&& ( ( y2_min > y1_min && y2_max < y1_max ) || y2_min == y2_max ) && ( ( y2_min > y1_min && y2_max < y1_max ) || y2_min == y2_max )
hasNaNs :: T (𝕀ℝ 2) -> Bool hasNaNs :: T (𝕀ℝ 2) -> Bool
hasNaNs ( T ( 𝕀 ( ℝ2 x_min y_min ) ( ℝ2 x_max y_max ) ) ) = hasNaNs ( T ( 𝕀ℝ2 ( 𝕀 x_min x_max ) ( 𝕀 y_min y_max ) ) ) =
any ( \ x -> isNaN x || isInfinite x ) [ x_min, y_min, x_max, y_max ] any ( \ x -> isNaN x || isInfinite x ) [ x_min, y_min, x_max, y_max ]
intervalSystem2D_LP intervalSystem2D_LP
:: forall d :: forall d
. ( KnownNat d, Representable Double ( ℝ d ) ) . ( KnownNat d, Representable 𝕀 ( 𝕀ℝ d ) )
=> Vec 2 ( 𝕀ℝ d ) => Vec 2 ( 𝕀ℝ d )
-> 𝕀ℝ d -> 𝕀ℝ d
-> T ( 𝕀ℝ 2 ) -> T ( 𝕀ℝ 2 )
@ -94,7 +94,7 @@ intervalSystem2D_LP a b x =
d = natVal' @d proxy# d = natVal' @d proxy#
mkEquationArray mkEquationArray
:: ( KnownNat d, Representable Double ( ℝ d ) ) :: ( KnownNat d, Representable 𝕀 ( 𝕀ℝ d ) )
=> Vec 2 ( 𝕀ℝ d ) -> 𝕀ℝ d -> [ CEqn ] => Vec 2 ( 𝕀ℝ d ) -> 𝕀ℝ d -> [ CEqn ]
mkEquationArray ( Vec [ a_x, a_y ] ) b = mkEquationArray ( Vec [ a_x, a_y ] ) b =
[ CEqn a_x_i a_y_i b_i [ CEqn a_x_i a_y_i b_i
@ -107,7 +107,7 @@ mkEquationArray _ _ = error "impossible"
foreign import ccall "interval_system_2d" foreign import ccall "interval_system_2d"
interval_system_2d :: Ptr CBox -> Ptr CBox -> Ptr CEqn -> CUInt -> IO CInt interval_system_2d :: Ptr CBox -> Ptr CBox -> Ptr CEqn -> CUInt -> IO CInt
data CEqn = CEqn !( 𝕀 Double ) !( 𝕀 Double ) !( 𝕀 Double ) data CEqn = CEqn !𝕀 !𝕀 !𝕀
instance Storable CEqn where instance Storable CEqn where
sizeOf _ = 6 * sizeOf @Double undefined sizeOf _ = 6 * sizeOf @Double undefined
alignment _ = 4 * alignment @Double undefined alignment _ = 4 * alignment @Double undefined
@ -127,6 +127,6 @@ instance Storable CBox where
peek ptr = do peek ptr = do
[ CDouble x_min, CDouble x_max, CDouble y_min, CDouble y_max ] <- peekArray 4 ( castPtr ptr :: Ptr CDouble ) [ CDouble x_min, CDouble x_max, CDouble y_min, CDouble y_max ] <- peekArray 4 ( castPtr ptr :: Ptr CDouble )
return $ return $
CBox ( 𝕀 ( ℝ2 x_min y_min ) ( ℝ2 x_max y_max ) ) CBox ( 𝕀ℝ2 ( 𝕀 x_min x_max ) ( 𝕀 y_min y_max ) )
poke ptr ( CBox ( 𝕀 ( ℝ2 x_min y_min ) ( ℝ2 x_max y_max ) ) ) = poke ptr ( CBox ( 𝕀ℝ2 ( 𝕀 x_min x_max ) ( 𝕀 y_min y_max ) ) ) =
pokeArray ( castPtr ptr ) [ CDouble x_min, CDouble x_max, CDouble y_min, CDouble y_max ] pokeArray ( castPtr ptr ) [ CDouble x_min, CDouble x_max, CDouble y_min, CDouble y_max ]

10
brush-strokes/src/lib/Math/Root/Isolation/Utils.hs
View file

@ -20,8 +20,8 @@ import Math.Linear
fromComponents fromComponents
:: forall n :: forall n
. ( Representable Double ( ℝ n ), n ~ RepDim ( ℝ n ) ) . ( Representable 𝕀 ( 𝕀ℝ n ), n ~ RepDim ( 𝕀ℝ n ) )
=> ( Fin n -> [ ( 𝕀 Double, Bool ) ] ) -> [ ( 𝕀ℝ n, Vec n Bool ) ] => ( Fin n -> [ ( 𝕀, Bool ) ] ) -> [ ( 𝕀ℝ n, Vec n Bool ) ]
fromComponents f = do fromComponents f = do
( xs, bs ) <- unzip <$> traverse f ( universe @n ) ( xs, bs ) <- unzip <$> traverse f ( universe @n )
return $ ( tabulate $ \ i -> xs ! i, bs ) return $ ( tabulate $ \ i -> xs ! i, bs )
@ -29,7 +29,7 @@ fromComponents f = do
{-# INLINEABLE fromComponents #-} {-# INLINEABLE fromComponents #-}
-- | The midpoint of a box. -- | The midpoint of a box.
boxMidpoint :: Representable Double ( ℝ n ) => 𝕀ℝ n -> ℝ n boxMidpoint :: ( Representable 𝕀 ( 𝕀ℝ n ), Representable Double ( ℝ n ) ) => 𝕀ℝ n -> ℝ n
boxMidpoint box = boxMidpoint box =
tabulate $ \ i -> midpoint ( box `index` i ) tabulate $ \ i -> midpoint ( box `index` i )
{-# INLINEABLE boxMidpoint #-} {-# INLINEABLE boxMidpoint #-}
@ -37,7 +37,9 @@ boxMidpoint box =
-- | Matrix multiplication \( A v \). -- | Matrix multiplication \( A v \).
matMulVec matMulVec
:: forall n m :: forall n m
. ( Representable Double ( ℝ n ), Representable Double ( ℝ m ) ) . ( Representable 𝕀 ( 𝕀ℝ n ), Representable 𝕀 ( 𝕀ℝ m )
, Representable Double ( ℝ n ), Representable Double ( ℝ m )
)
=> Vec m ( ℝ n ) -- ^ columns of the matrix \( A ) => Vec m ( ℝ n ) -- ^ columns of the matrix \( A )
-> 𝕀ℝ m -- ^ vector \( v \) -> 𝕀ℝ m -- ^ vector \( v \)
-> 𝕀ℝ n -> 𝕀ℝ n

15
cabal.project
View file

@ -50,3 +50,18 @@ source-repository-package
type: git type: git
location: https://github.com/sheaf/eigen location: https://github.com/sheaf/eigen
tag: 3bc1d4bc53edb75e2ee3893763361aa0d5c7714a tag: 3bc1d4bc53edb75e2ee3893763361aa0d5c7714a
--------------
-- GHC HEAD --
--------------
repository head.hackage.ghc.haskell.org
url: https://ghc.gitlab.haskell.org/head.hackage/
secure: True
key-threshold: 3
root-keys:
f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89
26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329
7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d
active-repositories: hackage.haskell.org, head.hackage.ghc.haskell.org:override