{-# LANGUAGE BangPatterns     #-}
{-# LANGUAGE FlexibleContexts #-}
module MarchingCubes.Internal
  ( module MarchingCubes.Internal
  ) where
import           Data.Array.Unboxed             ( IArray(..)
                                                , UArray
                                                )
import qualified Data.Array.Unboxed            as A
import           Data.Bits                      ( shiftL )
import qualified Data.Foldable                 as F
import           Data.List                      ( zipWith4 )
import           Data.Matrix                    ( Matrix(..)
                                                , elementwiseUnsafe
                                                , fromLists
                                                , getElem
                                                , getRow
                                                , matrix
                                                , minorMatrix
                                                , scaleMatrix
                                                )
import qualified Data.Matrix                   as M
import           Data.Sequence                  ( Seq
                                                , (|>)
                                                )
import qualified Data.Sequence                 as S
import qualified Data.Vector                   as V
import           Data.Vector.Unboxed            ( (!)
                                                , Unbox
                                                , Vector
                                                )
import qualified Data.Vector.Unboxed           as UV
import           MarchingCubes.Tables           ( crf
                                                , facePoints
                                                , indexArray
                                                )
import           MarchingCubes.Utils            ( arrayToMatrix
                                                , kro1
                                                , kro2
                                                , levelMatrix
                                                , whichIndicesAndItems
                                                )

facesNo7
  :: (Num a, Ord a, Unbox a)
  => Vector Int
  -> Vector Int
  -> Vector a
  -> Int
  -> Int
  -> [Int]
facesNo7 :: forall a.
(Num a, Ord a, Unbox a) =>
Vector Int -> Vector Int -> Vector a -> Int -> Int -> [Int]
facesNo7 Vector Int
faces Vector Int
p1 Vector a
values Int
l Int
j = forall a b. (a -> b) -> [a] -> [b]
map forall {a}. (Bits a, Num a) => Int -> a
fun [Int
0 .. Int
l forall a. Num a => a -> a -> a
- Int
1]
 where
  fun :: Int -> a
fun Int
i = if Int
temp forall a. Eq a => a -> a -> Bool
== Int
1 then forall a. Bits a => a -> Int -> a
shiftL a
1 (Int
j forall a. Num a => a -> a -> a
- Int
1) else a
0
   where
    f :: Int
f  = forall a. Num a => a -> a
abs (Vector Int
faces forall a. Unbox a => Vector a -> Int -> a
! Int
i) forall a. Num a => a -> a -> a
- Int
1
    e :: Vector Int
e  = Vector (Vector Int)
facePoints forall a. Vector a -> Int -> a
V.! Int
f
    e1 :: Int
e1 = Vector Int
e forall a. Unbox a => Vector a -> Int -> a
! Int
1
    e2 :: Int
e2 = Vector Int
e forall a. Unbox a => Vector a -> Int -> a
! Int
2
    e3 :: Int
e3 = Vector Int
e forall a. Unbox a => Vector a -> Int -> a
! Int
3
    e4 :: Int
e4 = Vector Int
e forall a. Unbox a => Vector a -> Int -> a
! Int
4
    p :: Int
p  = Vector Int
p1 forall a. Unbox a => Vector a -> Int -> a
! Int
i forall a. Num a => a -> a -> a
- Int
2
    a :: a
a  = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
e1)
    b :: a
b  = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
e2)
    c :: a
c  = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
e3)
    d :: a
d  = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
e4)
    temp :: Int
temp =
      (if Vector Int
faces forall a. Unbox a => Vector a -> Int -> a
! Int
i forall a. Ord a => a -> a -> Bool
> Int
0 then Int
1 :: Int else -Int
1)
        forall a. Num a => a -> a -> a
* (if a
a forall a. Num a => a -> a -> a
* a
b forall a. Num a => a -> a -> a
- a
c forall a. Num a => a -> a -> a
* a
d forall a. Ord a => a -> a -> Bool
> a
0 then Int
1 else -Int
1)

faces7
  :: (RealFloat a, Unbox a)
  => Vector Int
  -> Vector Int
  -> Vector a
  -> Int
  -> Int
  -> [Int]
faces7 :: forall a.
(RealFloat a, Unbox a) =>
Vector Int -> Vector Int -> Vector a -> Int -> Int -> [Int]
faces7 Vector Int
faces Vector Int
p1 Vector a
values Int
l Int
j = forall a b. (a -> b) -> [a] -> [b]
map forall {a}. (Bits a, Num a) => Int -> a
fun [Int
0 .. Int
l forall a. Num a => a -> a -> a
- Int
1]
 where
  fun :: Int -> a
fun Int
i = if Int
temp forall a. Eq a => a -> a -> Bool
== Int
1 then forall a. Bits a => a -> Int -> a
shiftL a
1 (Int
j forall a. Num a => a -> a -> a
- Int
1) else a
0
   where
    p :: Int
p         = (Vector Int
p1 forall a. Unbox a => Vector a -> Int -> a
! Int
i) forall a. Num a => a -> a -> a
- Int
1
    a0 :: a
a0        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! Int
p
    b0 :: a
b0        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
3)
    c0 :: a
c0        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
2)
    d0 :: a
d0        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
1)
    a1 :: a
a1        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
4)
    b1 :: a
b1        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
7)
    c1 :: a
c1        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
6)
    d1 :: a
d1        = Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
p forall a. Num a => a -> a -> a
+ Int
5)
    a :: a
a         = (a
a1 forall a. Num a => a -> a -> a
- a
a0) forall a. Num a => a -> a -> a
* (a
c1 forall a. Num a => a -> a -> a
- a
c0) forall a. Num a => a -> a -> a
- (a
b1 forall a. Num a => a -> a -> a
- a
b0) forall a. Num a => a -> a -> a
* (a
d1 forall a. Num a => a -> a -> a
- a
d0)
    b :: a
b = a
c0 forall a. Num a => a -> a -> a
* (a
a1 forall a. Num a => a -> a -> a
- a
a0) forall a. Num a => a -> a -> a
+ a
a0 forall a. Num a => a -> a -> a
* (a
c1 forall a. Num a => a -> a -> a
- a
c0) forall a. Num a => a -> a -> a
- a
d0 forall a. Num a => a -> a -> a
* (a
b1 forall a. Num a => a -> a -> a
- a
b0) forall a. Num a => a -> a -> a
- a
b0 forall a. Num a => a -> a -> a
* (a
d1 forall a. Num a => a -> a -> a
- a
d0)
    c :: a
c         = a
a0 forall a. Num a => a -> a -> a
* a
c0 forall a. Num a => a -> a -> a
- a
b0 forall a. Num a => a -> a -> a
* a
d0
    tmax :: a
tmax      = -a
b forall a. Fractional a => a -> a -> a
/ a
2 forall a. Fractional a => a -> a -> a
/ a
a
    mxmm :: a
mxmm      = a
a forall a. Num a => a -> a -> a
* a
tmax forall a. Num a => a -> a -> a
* a
tmax forall a. Num a => a -> a -> a
+ a
b forall a. Num a => a -> a -> a
* a
tmax forall a. Num a => a -> a -> a
+ a
c
    mxmm' :: a
mxmm'     = if forall a. RealFloat a => a -> Bool
isNaN a
mxmm then -a
1 else a
mxmm
    cond1 :: Bool
cond1     = a
a forall a. Ord a => a -> a -> Bool
< a
0
    cond2 :: Bool
cond2     = a
tmax forall a. Ord a => a -> a -> Bool
> a
0
    cond3 :: Bool
cond3     = a
tmax forall a. Ord a => a -> a -> Bool
< a
1
    cond4 :: Bool
cond4     = a
mxmm' forall a. Ord a => a -> a -> Bool
> a
0
    totalcond :: Bool
totalcond = Bool
cond1 Bool -> Bool -> Bool
&& Bool
cond2 Bool -> Bool -> Bool
&& Bool
cond3 Bool -> Bool -> Bool
&& Bool
cond4
    temp :: Int
temp =
      (if Vector Int
faces forall a. Unbox a => Vector a -> Int -> a
! Int
i forall a. Ord a => a -> a -> Bool
> Int
0 then Int
1 :: Int else -Int
1) forall a. Num a => a -> a -> a
* (if Bool
totalcond then Int
1 else -Int
1)

faceType :: Real a => Matrix a -> a -> a -> Matrix Int
faceType :: forall a. Real a => Matrix a -> a -> a -> Matrix Int
faceType Matrix a
mtrx a
level a
mx = forall a b c. (a -> b -> c) -> Matrix a -> Matrix b -> Matrix c
elementwiseUnsafe forall a. Num a => a -> a -> a
(+) Matrix Int
sum1 Matrix Int
sum2
 where
  lm :: Matrix Int
lm         = forall a. Real a => Matrix a -> a -> Bool -> Matrix Int
levelMatrix Matrix a
mtrx a
level (a
level forall a. Ord a => a -> a -> Bool
< a
mx)
  m :: Int
m          = forall a. Matrix a -> Int
nrows Matrix a
mtrx
  n :: Int
n          = forall a. Matrix a -> Int
ncols Matrix a
mtrx
  minorMat :: Matrix Int
minorMat   = forall a. Int -> Int -> Matrix a -> Matrix a
minorMatrix Int
m Int
n Matrix Int
lm
  sminorMat2 :: Matrix Int
sminorMat2 = forall a. Num a => a -> Matrix a -> Matrix a
scaleMatrix Int
2 (forall a. Int -> Int -> Matrix a -> Matrix a
minorMatrix Int
1 Int
n Matrix Int
lm)
  sminorMat4 :: Matrix Int
sminorMat4 = forall a. Num a => a -> Matrix a -> Matrix a
scaleMatrix Int
4 (forall a. Int -> Int -> Matrix a -> Matrix a
minorMatrix Int
1 Int
1 Matrix Int
lm)
  sminorMat8 :: Matrix Int
sminorMat8 = forall a. Num a => a -> Matrix a -> Matrix a
scaleMatrix Int
8 (forall a. Int -> Int -> Matrix a -> Matrix a
minorMatrix Int
m Int
1 Matrix Int
lm)
  sum1 :: Matrix Int
sum1       = forall a b c. (a -> b -> c) -> Matrix a -> Matrix b -> Matrix c
elementwiseUnsafe forall a. Num a => a -> a -> a
(+) Matrix Int
minorMat Matrix Int
sminorMat2
  sum2 :: Matrix Int
sum2       = forall a b c. (a -> b -> c) -> Matrix a -> Matrix b -> Matrix c
elementwiseUnsafe forall a. Num a => a -> a -> a
(+) Matrix Int
sminorMat4 Matrix Int
sminorMat8

levCells
  :: (Real a, IArray UArray a)
  => UArray (Int, Int, Int) a
  -> a
  -> a
  -> Matrix Int
levCells :: forall a.
(Real a, IArray UArray a) =>
UArray (Int, Int, Int) a -> a -> a -> Matrix Int
levCells UArray (Int, Int, Int) a
a a
level a
mx = Matrix Int
out
 where
  bottomTypes :: Matrix Int
bottomTypes             = forall a. Real a => Matrix a -> a -> a -> Matrix Int
faceType (forall a.
IArray UArray a =>
UArray (Int, Int, Int) a -> Int -> Matrix a
arrayToMatrix UArray (Int, Int, Int) a
a Int
0) a
level a
mx
  ((Int, Int, Int)
_, (Int
nx', Int
ny', Int
nz'))    = forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds UArray (Int, Int, Int) a
a
  -- nx = nx' + 1
  -- ny = ny' + 1
  -- nz = nz' + 1
  (Seq Int
lengths, Seq (Seq Int)
cells, Seq (Seq Int)
types) = Int
-> Seq Int
-> Matrix Int
-> Seq (Seq Int)
-> Seq (Seq Int)
-> (Seq Int, Seq (Seq Int), Seq (Seq Int))
go Int
0 forall a. Seq a
S.empty Matrix Int
bottomTypes forall a. Seq a
S.empty forall a. Seq a
S.empty
  go
    :: Int
    -> Seq Int
    -> Matrix Int
    -> Seq (Seq Int)
    -> Seq (Seq Int)
    -> (Seq Int, Seq (Seq Int), Seq (Seq Int))
  go :: Int
-> Seq Int
-> Matrix Int
-> Seq (Seq Int)
-> Seq (Seq Int)
-> (Seq Int, Seq (Seq Int), Seq (Seq Int))
go Int
k !Seq Int
lngths !Matrix Int
bTypes !Seq (Seq Int)
clls !Seq (Seq Int)
tps
    | Int
k forall a. Eq a => a -> a -> Bool
== Int
nz'  = (Seq Int
lngths, Seq (Seq Int)
clls, Seq (Seq Int)
tps)
    | Bool
otherwise = Int
-> Seq Int
-> Matrix Int
-> Seq (Seq Int)
-> Seq (Seq Int)
-> (Seq Int, Seq (Seq Int), Seq (Seq Int))
go (Int
k forall a. Num a => a -> a -> a
+ Int
1) (Seq Int
lngths forall a. Seq a -> a -> Seq a
|> Int
l) Matrix Int
tTypes (Seq (Seq Int)
clls forall a. Seq a -> a -> Seq a
|> Seq Int
cll) (Seq (Seq Int)
tps forall a. Seq a -> a -> Seq a
|> Seq Int
tp)
   where
    tTypes :: Matrix Int
tTypes    = forall a. Real a => Matrix a -> a -> a -> Matrix Int
faceType (forall a.
IArray UArray a =>
UArray (Int, Int, Int) a -> Int -> Matrix a
arrayToMatrix UArray (Int, Int, Int) a
a (Int
k forall a. Num a => a -> a -> a
+ Int
1)) a
level a
mx
    cellTypes :: Matrix Int
cellTypes = forall a b c. (a -> b -> c) -> Matrix a -> Matrix b -> Matrix c
elementwiseUnsafe forall a. Num a => a -> a -> a
(+) Matrix Int
bTypes (forall a. Num a => a -> Matrix a -> Matrix a
scaleMatrix Int
16 Matrix Int
tTypes)
    goodcells :: Seq (Int, Int)
goodcells = Matrix Int -> Seq (Int, Int)
whichIndicesAndItems Matrix Int
cellTypes
    l :: Int
l         = forall a. Seq a -> Int
S.length Seq (Int, Int)
goodcells
    cll :: Seq Int
cll       = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Int
i, Int
_) -> Int
i forall a. Num a => a -> a -> a
+ Int
nx' forall a. Num a => a -> a -> a
* Int
ny' forall a. Num a => a -> a -> a
* Int
k forall a. Num a => a -> a -> a
+ Int
1) Seq (Int, Int)
goodcells
    tp :: Seq Int
tp        = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd Seq (Int, Int)
goodcells
  out :: Matrix Int
out = forall a. Matrix a -> Matrix a
M.transpose (forall a. [[a]] -> Matrix a
fromLists (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Int -> [[Int]]
f [Int
0 .. Int
nz' forall a. Num a => a -> a -> a
- Int
1]))
  f :: Int -> [[Int]]
f Int
k = forall a b. (a -> b) -> [a] -> [b]
map (Int -> Int -> [Int]
g Int
k) [Int
0 .. forall a. Seq a -> Int -> a
S.index Seq Int
lengths Int
k forall a. Num a => a -> a -> a
- Int
1]
  g :: Int -> Int -> [Int]
g Int
k Int
l =
    [ Int
c forall a. Integral a => a -> a -> a
`mod` Int
nx' forall a. Num a => a -> a -> a
+ Int
1
    , (Int
c forall a. Integral a => a -> a -> a
`div` Int
nx') forall a. Integral a => a -> a -> a
`mod` Int
ny' forall a. Num a => a -> a -> a
+ Int
1
    , Int
c forall a. Integral a => a -> a -> a
`div` (Int
nx' forall a. Num a => a -> a -> a
* Int
ny') forall a. Num a => a -> a -> a
+ Int
1
    , forall a. Seq a -> Int -> a
S.index (forall a. Seq a -> Int -> a
S.index Seq (Seq Int)
types Int
k) Int
l
    ]
    where c :: Int
c = forall a. Seq a -> Int -> a
S.index (forall a. Seq a -> Int -> a
S.index Seq (Seq Int)
cells Int
k) Int
l forall a. Num a => a -> a -> a
- Int
1

getBasic1 :: Vector Int -> Matrix Int -> Matrix Int
getBasic1 :: Vector Int -> Matrix Int -> Matrix Int
getBasic1 Vector Int
r Matrix Int
vivjvk = forall a b c. (a -> b -> c) -> Matrix a -> Matrix b -> Matrix c
elementwiseUnsafe forall a. Num a => a -> a -> a
(+) Matrix Int
k1 Matrix Int
k2
 where
  nR :: Int
nR    = forall a. Unbox a => Vector a -> Int
UV.length Vector Int
r
  cube1 :: Matrix Int
cube1 = forall a. Int -> Int -> ((Int, Int) -> a) -> Matrix a
matrix Int
nR Int
3 (\(Int
i, Int
j) -> forall a. Int -> Int -> Matrix a -> a
getElem (Vector Int
r forall a. Unbox a => Vector a -> Int -> a
! (Int
i forall a. Num a => a -> a -> a
- Int
1) forall a. Num a => a -> a -> a
+ Int
1) Int
j Matrix Int
vivjvk)
  k1 :: Matrix Int
k1    = Matrix Int -> Int -> Matrix Int
kro1 Matrix Int
indexArray Int
nR
  k2 :: Matrix Int
k2    = Matrix Int -> Int -> Matrix Int
kro2 Matrix Int
cube1 Int
8

getBasic2
  :: (Num a, Unbox a, IArray UArray a)
  => UArray (Int, Int, Int) a
  -> a
  -> Matrix Int
  -> Vector a
getBasic2 :: forall a.
(Num a, Unbox a, IArray UArray a) =>
UArray (Int, Int, Int) a -> a -> Matrix Int -> Vector a
getBasic2 UArray (Int, Int, Int) a
a a
level Matrix Int
cubeco = forall a. Unbox a => [a] -> Vector a
UV.fromList [a]
values
 where
  f :: Int -> Int -> Int
f Int
i Int
j = forall a. Int -> Int -> Matrix a -> a
getElem Int
i Int
j Matrix Int
cubeco forall a. Num a => a -> a -> a
- Int
1
  values :: [a]
values =
    [ UArray (Int, Int, Int) a
a forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
A.! (Int -> Int -> Int
f Int
i Int
1, Int -> Int -> Int
f Int
i Int
2, Int -> Int -> Int
f Int
i Int
3) forall a. Num a => a -> a -> a
- a
level | Int
i <- [Int
1 .. forall a. Matrix a -> Int
nrows Matrix Int
cubeco forall a. Num a => a -> a -> a
- Int
1] ]
    forall a. [a] -> [a] -> [a]
++ [a
0]

getTcase :: V.Vector Int -> Vector Int
getTcase :: Vector Int -> Vector Int
getTcase Vector Int
types =
  forall a. Unbox a => [a] -> Vector a
UV.fromList [ Vector Int
crf forall a. Unbox a => Vector a -> Int -> a
! (Vector Int
types forall a. Vector a -> Int -> a
V.! Int
i) forall a. Num a => a -> a -> a
- Int
1 | Int
i <- [Int
0 .. forall a. Vector a -> Int
V.length Vector Int
types forall a. Num a => a -> a -> a
- Int
1] ]

getR :: Vector Int -> Vector Int
getR :: Vector Int -> Vector Int
getR Vector Int
tcase = forall a. Unbox a => [a] -> Vector a
UV.fromList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList forall a b. (a -> b) -> a -> b
$ Int -> Seq Int -> Seq Int
go Int
0 forall a. Seq a
S.empty
 where
  n :: Int
n = forall a. Unbox a => Vector a -> Int
UV.length Vector Int
tcase
  go :: Int -> Seq Int -> Seq Int
  go :: Int -> Seq Int -> Seq Int
go Int
i !Seq Int
out
    | Int
i forall a. Eq a => a -> a -> Bool
== Int
n
    = Seq Int
out
    | Bool
otherwise
    = if Int
tc forall a. Eq a => a -> a -> Bool
== Int
1
      Bool -> Bool -> Bool
|| Int
tc forall a. Eq a => a -> a -> Bool
== Int
2
      Bool -> Bool -> Bool
|| Int
tc forall a. Eq a => a -> a -> Bool
== Int
5
      Bool -> Bool -> Bool
|| Int
tc forall a. Eq a => a -> a -> Bool
== Int
8
      Bool -> Bool -> Bool
|| Int
tc forall a. Eq a => a -> a -> Bool
== Int
9
      Bool -> Bool -> Bool
|| Int
tc forall a. Eq a => a -> a -> Bool
== Int
11
      Bool -> Bool -> Bool
|| Int
tc forall a. Eq a => a -> a -> Bool
== Int
14
      then
        Int -> Seq Int -> Seq Int
go (Int
i forall a. Num a => a -> a -> a
+ Int
1) (Seq Int
out forall a. Seq a -> a -> Seq a
|> Int
i)
      else
        Int -> Seq Int -> Seq Int
go (Int
i forall a. Num a => a -> a -> a
+ Int
1) Seq Int
out
    where tc :: Int
tc = Vector Int
tcase forall a. Unbox a => Vector a -> Int -> a
! Int
i

lambdaMu :: RealFrac a => [a] -> ([a], [a])
lambdaMu :: forall a. RealFrac a => [a] -> ([a], [a])
lambdaMu [a]
x1 = ([a]
lambda, [a]
mu)
 where
  lambda :: [a]
lambda = forall a b. (a -> b) -> [a] -> [b]
map (\a
x -> forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
floor (a
x forall a. Fractional a => a -> a -> a
/ a
9)) [a]
x1
  mu :: [a]
mu     = forall a b. (a -> b) -> [a] -> [b]
map (a
1 forall a. Num a => a -> a -> a
-) [a]
lambda

average :: Num a => ([a], [a]) -> [a] -> [a] -> [a]
average :: forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a]
lambda, [a]
mu) = forall a b c d e.
(a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWith4 (\a
a a
b a
c a
d -> a
b forall a. Num a => a -> a -> a
* a
c forall a. Num a => a -> a -> a
+ a
a forall a. Num a => a -> a -> a
* a
d) [a]
lambda [a]
mu

average7 :: Num a => ([a], [a]) -> [a] -> [a]
average7 :: forall a. Num a => ([a], [a]) -> [a] -> [a]
average7 ([a]
lambda, [a]
mu) = forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 (\a
a a
b a
c -> a
b forall a. Num a => a -> a -> a
* a
c forall a. Num a => a -> a -> a
+ a
a) [a]
lambda [a]
mu

average8 :: Num a => ([a], [a]) -> [a] -> [a]
average8 :: forall a. Num a => ([a], [a]) -> [a] -> [a]
average8 ([a]
lambda, [a]
mu) = forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 (\a
a a
b a
c -> a
b forall a. Num a => a -> a -> a
* a
c forall a. Num a => a -> a -> a
- a
a) [a]
lambda [a]
mu

getPoints
  :: (Unbox a, RealFrac a)
  => Matrix Int
  -> Vector a
  -> [Int]
  -> [Int]
  -> [Int]
  -> Matrix a
getPoints :: forall a.
(Unbox a, RealFrac a) =>
Matrix Int -> Vector a -> [Int] -> [Int] -> [Int] -> Matrix a
getPoints Matrix Int
cubeco Vector a
values [Int]
p1 [Int]
x1 [Int]
x2 = forall a. [[a]] -> Matrix a
fromLists
  [[a]
out0, [a]
out1, [a]
out2, [a]
out3, [a]
out4, [a]
out5, [a]
out6, [a]
out7]
 where
  p1x1 :: [Int]
p1x1     = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(+) [Int]
p1 [Int]
x1
  p1x2 :: [Int]
p1x2     = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. Num a => a -> a -> a
(+) [Int]
p1 [Int]
x2
  xx1 :: [a]
xx1      = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (Integral a, Num b) => a -> b
fromIntegral [Int]
x1
  lambdamu :: ([a], [a])
lambdamu = forall a. RealFrac a => [a] -> ([a], [a])
lambdaMu [a]
xx1
  v1 :: [a]
v1       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
- Int
1) Int
1 Matrix Int
cubeco) [Int]
p1x1
  w1 :: [a]
w1       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem Int
j Int
1 Matrix Int
cubeco) [Int]
p1
  v2 :: [a]
v2       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
- Int
1) Int
1 Matrix Int
cubeco) [Int]
p1x2
  w2 :: [a]
w2       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
+ Int
1) Int
1 Matrix Int
cubeco) [Int]
p1
  v3 :: [a]
v3       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
- Int
1) Int
2 Matrix Int
cubeco) [Int]
p1x1
  w3 :: [a]
w3       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
+ Int
1) Int
2 Matrix Int
cubeco) [Int]
p1
  v4 :: [a]
v4       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
- Int
1) Int
2 Matrix Int
cubeco) [Int]
p1x2
  w4 :: [a]
w4       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
+ Int
2) Int
2 Matrix Int
cubeco) [Int]
p1
  v5 :: [a]
v5       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
- Int
1) Int
3 Matrix Int
cubeco) [Int]
p1x1
  w5 :: [a]
w5       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
+ Int
1) Int
3 Matrix Int
cubeco) [Int]
p1
  v6 :: [a]
v6       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
- Int
1) Int
3 Matrix Int
cubeco) [Int]
p1x2
  w6 :: [a]
w6       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Int -> Int -> Matrix a -> a
getElem (Int
j forall a. Num a => a -> a -> a
+ Int
5) Int
3 Matrix Int
cubeco) [Int]
p1
  v7 :: [a]
v7       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
j forall a. Num a => a -> a -> a
- Int
2)) [Int]
p1x1
  v8 :: [a]
v8       = forall a b. (a -> b) -> [a] -> [b]
map (\Int
j -> Vector a
values forall a. Unbox a => Vector a -> Int -> a
! (Int
j forall a. Num a => a -> a -> a
- Int
2)) [Int]
p1x2
  out0 :: [a]
out0     = forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a], [a])
lambdamu [a]
v1 [a]
w1
  out1 :: [a]
out1     = forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a], [a])
lambdamu [a]
v2 [a]
w2
  out2 :: [a]
out2     = forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a], [a])
lambdamu [a]
v3 [a]
w3
  out3 :: [a]
out3     = forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a], [a])
lambdamu [a]
v4 [a]
w4
  out4 :: [a]
out4     = forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a], [a])
lambdamu [a]
v5 [a]
w5
  out5 :: [a]
out5     = forall a. Num a => ([a], [a]) -> [a] -> [a] -> [a]
average ([a], [a])
lambdamu [a]
v6 [a]
w6
  out6 :: [a]
out6     = forall a. Num a => ([a], [a]) -> [a] -> [a]
average7 ([a], [a])
lambdamu [a]
v7
  out7 :: [a]
out7     = forall a. Num a => ([a], [a]) -> [a] -> [a]
average8 ([a], [a])
lambdamu [a]
v8

calPoints :: Fractional a => Matrix a -> Matrix a
calPoints :: forall a. Fractional a => Matrix a -> Matrix a
calPoints Matrix a
points = forall a. Matrix a -> Matrix a
M.transpose forall a b. (a -> b) -> a -> b
$ forall a. [[a]] -> Matrix a
fromLists [[a]
x, [a]
y, [a]
z]
 where
  x1 :: Vector a
x1 = forall a. Int -> Matrix a -> Vector a
getRow Int
1 Matrix a
points
  x2 :: Vector a
x2 = forall a. Int -> Matrix a -> Vector a
getRow Int
2 Matrix a
points
  y1 :: Vector a
y1 = forall a. Int -> Matrix a -> Vector a
getRow Int
3 Matrix a
points
  y2 :: Vector a
y2 = forall a. Int -> Matrix a -> Vector a
getRow Int
4 Matrix a
points
  z1 :: Vector a
z1 = forall a. Int -> Matrix a -> Vector a
getRow Int
5 Matrix a
points
  z2 :: Vector a
z2 = forall a. Int -> Matrix a -> Vector a
getRow Int
6 Matrix a
points
  v1 :: Vector a
v1 = forall a. Int -> Matrix a -> Vector a
getRow Int
7 Matrix a
points
  v2 :: Vector a
v2 = forall a. Int -> Matrix a -> Vector a
getRow Int
8 Matrix a
points
  s :: Vector a
s  = forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith (\a
a a
b -> a
a forall a. Fractional a => a -> a -> a
/ (a
a forall a. Num a => a -> a -> a
- a
b)) Vector a
v1 Vector a
v2
  x :: [a]
x  = forall a. Vector a -> [a]
V.toList forall a b. (a -> b) -> a -> b
$ forall a b c d.
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
V.zipWith3 (\a
a a
b a
c -> a
a forall a. Num a => a -> a -> a
+ a
c forall a. Num a => a -> a -> a
* (a
b forall a. Num a => a -> a -> a
- a
a)) Vector a
x1 Vector a
x2 Vector a
s
  y :: [a]
y  = forall a. Vector a -> [a]
V.toList forall a b. (a -> b) -> a -> b
$ forall a b c d.
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
V.zipWith3 (\a
a a
b a
c -> a
a forall a. Num a => a -> a -> a
+ a
c forall a. Num a => a -> a -> a
* (a
b forall a. Num a => a -> a -> a
- a
a)) Vector a
y1 Vector a
y2 Vector a
s
  z :: [a]
z  = forall a. Vector a -> [a]
V.toList forall a b. (a -> b) -> a -> b
$ forall a b c d.
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
V.zipWith3 (\a
a a
b a
c -> a
a forall a. Num a => a -> a -> a
+ a
c forall a. Num a => a -> a -> a
* (a
b forall a. Num a => a -> a -> a
- a
a)) Vector a
z1 Vector a
z2 Vector a
s