-- |
-- Module      : Math.Manifold.Core.Types
-- Copyright   : (c) Justus Sagemüller 2016
-- License     : GPL v3
-- 
-- Maintainer  : (@) jsag $ hvl.no
-- Stability   : experimental
-- Portability : portable
-- 
-- Several low-dimensional manifolds, represented in some simple way as Haskell
-- data types. All these are in the 'PseudoAffine' class.
-- 


{-# LANGUAGE TypeFamilies             #-}
{-# LANGUAGE PatternSynonyms          #-}
{-# LANGUAGE ViewPatterns             #-}


module Math.Manifold.Core.Types
        ( EmptyMfd(..), ℝ⁰, ℝ
        , S⁰, S⁰_(..), otherHalfSphere, S¹, S¹_(..), pattern S¹, S², S²_(..), pattern S²
        , D¹, D¹_(..), fromIntv0to1, D², D²_(..), pattern D²
        , ℝP⁰, ℝP⁰_(..), ℝP¹, ℝP¹_(..), pattern ℝP¹, ℝP², ℝP²_(..), pattern ℝP²
        , Cℝay(..), CD¹(..)
        ) where

import Math.Manifold.Core.Types.Internal
import Math.Manifold.Core.PseudoAffine

import Data.VectorSpace
import Math.Manifold.VectorSpace.ZeroDimensional
import Data.AffineSpace
import Data.Basis
import Data.Void
import Data.Monoid





otherHalfSphere :: S⁰ -> S⁰
otherHalfSphere :: S⁰ -> S⁰
otherHalfSphere S⁰
PositiveHalfSphere = forall r. S⁰_ r
NegativeHalfSphere
otherHalfSphere S⁰
NegativeHalfSphere = forall r. S⁰_ r
PositiveHalfSphere

{-# DEPRECATED S¹ "Use Math.Manifold.Core.Types.S¹Polar" #-}
pattern S¹ :: Double -> S¹
pattern $bS¹ :: ℝ -> S¹
$mS¹ :: forall {r}. S¹ -> (ℝ -> r) -> ((# #) -> r) -> r
S¹ φ = S¹Polar φ

{-# DEPRECATED ℝP¹ "Use Math.Manifold.Core.Types.HemisphereℝP¹Polar (notice: different range)" #-}
pattern ℝP¹ :: Double -> ℝP¹
pattern $bℝP¹ :: ℝ -> ℝP¹
$mℝP¹ :: forall {r}. ℝP¹ -> (ℝ -> r) -> ((# #) -> r) -> r
ℝP¹ r <- (HemisphereℝP¹Polar ((2/pi*)->r))
 where ℝP¹ ℝ
r = forall r. r -> ℝP¹_ r
HemisphereℝP¹Polar forall a b. (a -> b) -> a -> b
$ ℝ
r forall a. Num a => a -> a -> a
* forall a. Floating a => a
piforall a. Fractional a => a -> a -> a
/ℝ
2

{-# DEPRECATED S² "Use Math.Manifold.Core.Types.S²Polar" #-}
pattern S² :: Double -> Double -> S²
pattern $bS² :: ℝ -> ℝ -> S²
$mS² :: forall {r}. S² -> (ℝ -> ℝ -> r) -> ((# #) -> r) -> r
S² ϑ φ = S²Polar ϑ φ

{-# DEPRECATED ℝP² "Use Math.Manifold.Core.Types.HemisphereℝP²Polar (notice: different range)" #-}
pattern ℝP² :: Double -> Double -> ℝP²
pattern $bℝP² :: ℝ -> ℝ -> ℝP²
$mℝP² :: forall {r}. ℝP² -> (ℝ -> ℝ -> r) -> ((# #) -> r) -> r
ℝP² r φ <- (HemisphereℝP²Polar ((2/pi*)->r) φ)
 where ℝP² ℝ
r ℝ
φ = forall r. r -> r -> ℝP²_ r
HemisphereℝP²Polar (ℝ
r forall a. Num a => a -> a -> a
* forall a. Floating a => a
piforall a. Fractional a => a -> a -> a
/ℝ
2) ℝ
φ

{-# DEPRECATED D² "Use Math.Manifold.Core.Types.D²Polar" #-}
pattern D² :: Double -> Double -> D²
pattern $bD² :: ℝ -> ℝ -> D²
$mD² :: forall {r}. D² -> (ℝ -> ℝ -> r) -> ((# #) -> r) -> r
D² r φ = D²Polar r φ


fromIntv0to1 :: ℝ -> D¹
fromIntv0to1 :: ℝ -> D¹
fromIntv0to1 ℝ
x | ℝ
xforall a. Ord a => a -> a -> Bool
<ℝ
0        = forall r. r -> D¹_ r
D¹ (-ℝ
1)
               | ℝ
xforall a. Ord a => a -> a -> Bool
>ℝ
1        = forall r. r -> D¹_ r
D¹ ℝ
1
               | Bool
otherwise  = forall r. r -> D¹_ r
D¹ forall a b. (a -> b) -> a -> b
$ ℝ
xforall a. Num a => a -> a -> a
*ℝ
2 forall a. Num a => a -> a -> a
- ℝ
1




instance VectorSpace () where
  type Scalar () = ℝ
  Scalar ()
_ *^ :: Scalar () -> () -> ()
*^ () = ()

instance HasBasis () where
  type Basis () = Void
  basisValue :: Basis () -> ()
basisValue = forall a. Void -> a
absurd
  decompose :: () -> [(Basis (), Scalar ())]
decompose () = []
  decompose' :: () -> Basis () -> Scalar ()
decompose' () = forall a. Void -> a
absurd
instance InnerSpace () where
  () <.> :: () -> () -> Scalar ()
<.> () = ℝ
0