support for Int64 elements

7 files changed, 129 insertions, 3 deletions

diff --git a/packages/base/src/Internal/C/vector-aux.c b/packages/base/src/Internal/C/vector-aux.c
index 0921c18..70e46bc 100644
--- a/packages/base/src/Internal/C/vector-aux.c
+++ b/packages/base/src/Internal/C/vector-aux.c
@@ -1365,7 +1365,7 @@ int int2double(KIVEC(x),DVEC(y)) CONVERT_IMP
 
 int int2long(KIVEC(x),LVEC(y)) CONVERT_IMP
 
-int lont2int(KLVEC(x),IVEC(y)) CONVERT_IMP
+int long2int(KLVEC(x),IVEC(y)) CONVERT_IMP
 
 int long2double(KLVEC(x),DVEC(y)) CONVERT_IMP
 
diff --git a/packages/base/src/Internal/Container.hs b/packages/base/src/Internal/Container.hs
index f6355b2..7fe5758 100644
--- a/packages/base/src/Internal/Container.hs
+++ b/packages/base/src/Internal/Container.hs
@@ -257,6 +257,7 @@ instance Numeric (Complex Double)
 instance Numeric Float
 instance Numeric (Complex Float)
 instance Numeric I
+instance Numeric Z
 
 --------------------------------------------------------------------------------
 
diff --git a/packages/base/src/Internal/Conversion.hs b/packages/base/src/Internal/Conversion.hs
index 2f4a9c7..4541ec4 100644
--- a/packages/base/src/Internal/Conversion.hs
+++ b/packages/base/src/Internal/Conversion.hs
@@ -44,6 +44,11 @@ instance Precision (Complex Float) (Complex Double) where
     double2FloatG = asComplex . double2FloatV . asReal
     float2DoubleG = asComplex . float2DoubleV . asReal
 
+instance Precision I Z where
+    double2FloatG = long2intV
+    float2DoubleG = int2longV
+
+
 -- | Supported real types
 class (Element t, Element (Complex t), RealFloat t)
     => RealElement t
diff --git a/packages/base/src/Internal/LAPACK.hs b/packages/base/src/Internal/LAPACK.hs
index d6a2e6e..469b0d5 100644
--- a/packages/base/src/Internal/LAPACK.hs
+++ b/packages/base/src/Internal/LAPACK.hs
@@ -37,6 +37,7 @@ foreign import ccall unsafe "multiplyC" zgemmc :: CInt -> CInt -> TMMM C
 foreign import ccall unsafe "multiplyF" sgemmc :: CInt -> CInt -> TMMM F
 foreign import ccall unsafe "multiplyQ" cgemmc :: CInt -> CInt -> TMMM Q
 foreign import ccall unsafe "multiplyI" c_multiplyI :: CInt ::> CInt ::> CInt ::> Ok
+foreign import ccall unsafe "multiplyL" c_multiplyL :: Z ::> Z ::> Z ::> Ok
 
 isT Matrix{order = ColumnMajor} = 0
 isT Matrix{order = RowMajor} = 1
@@ -75,6 +76,14 @@ multiplyI a b = unsafePerformIO $ do
     app3 c_multiplyI omat a omat b omat s "c_multiplyI"
     return s
 
+multiplyL :: Matrix Z -> Matrix Z -> Matrix Z
+multiplyL a b = unsafePerformIO $ do
+    when (cols a /= rows b) $ error $
+        "inconsistent dimensions in matrix product "++ shSize a ++ " x " ++ shSize b
+    s <- createMatrix ColumnMajor (rows a) (cols b)
+    app3 c_multiplyL omat a omat b omat s "c_multiplyL"
+    return s
+
 -----------------------------------------------------------------------------
 
 type TSVD t = t ..> t ..> R :> t ..> Ok
diff --git a/packages/base/src/Internal/Matrix.hs b/packages/base/src/Internal/Matrix.hs
index d715cbf..8de06ce 100644
--- a/packages/base/src/Internal/Matrix.hs
+++ b/packages/base/src/Internal/Matrix.hs
@@ -333,6 +333,16 @@ instance Element (CInt) where
     selectV    = selectI
     remapM     = remapI
 
+instance Element Z where
+    transdata  = transdataAux ctransL
+    constantD  = constantAux cconstantL
+    extractR   = extractAux c_extractL
+    sortI      = sortIdxL
+    sortV      = sortValL
+    compareV   = compareL
+    selectV    = selectL
+    remapM     = remapL
+
 -------------------------------------------------------------------
 
 transdataAux fun c1 d c2 =
@@ -357,6 +367,7 @@ foreign import ccall unsafe "transR" ctransR :: TMM Double
 foreign import ccall unsafe "transQ" ctransQ :: TMM (Complex Float)
 foreign import ccall unsafe "transC" ctransC :: TMM (Complex Double)
 foreign import ccall unsafe "transI" ctransI :: TMM CInt
+foreign import ccall unsafe "transL" ctransL :: TMM Z
 
 ----------------------------------------------------------------------
 
@@ -433,6 +444,7 @@ foreign import ccall unsafe "extractF" c_extractF :: Extr Float
 foreign import ccall unsafe "extractC" c_extractC :: Extr (Complex Double)
 foreign import ccall unsafe "extractQ" c_extractQ :: Extr (Complex Float)
 foreign import ccall unsafe "extractI" c_extractI :: Extr CInt
+foreign import ccall unsafe "extractL" c_extractL :: Extr Z
 
 --------------------------------------------------------------------------------
 
@@ -444,18 +456,22 @@ sortG f v = unsafePerformIO $ do
 sortIdxD = sortG c_sort_indexD
 sortIdxF = sortG c_sort_indexF
 sortIdxI = sortG c_sort_indexI
+sortIdxL = sortG c_sort_indexL
 
 sortValD = sortG c_sort_valD
 sortValF = sortG c_sort_valF
 sortValI = sortG c_sort_valI
+sortValL = sortG c_sort_valL
 
 foreign import ccall unsafe "sort_indexD" c_sort_indexD :: CV Double (CV CInt (IO CInt))
 foreign import ccall unsafe "sort_indexF" c_sort_indexF :: CV Float  (CV CInt (IO CInt))
 foreign import ccall unsafe "sort_indexI" c_sort_indexI :: CV CInt   (CV CInt (IO CInt))
+foreign import ccall unsafe "sort_indexL" c_sort_indexL :: Z :> I :> Ok
 
 foreign import ccall unsafe "sort_valuesD" c_sort_valD :: CV Double (CV Double (IO CInt))
 foreign import ccall unsafe "sort_valuesF" c_sort_valF :: CV Float  (CV Float (IO CInt))
 foreign import ccall unsafe "sort_valuesI" c_sort_valI :: CV CInt   (CV CInt (IO CInt))
+foreign import ccall unsafe "sort_valuesL" c_sort_valL :: Z :> Z :> Ok
 
 --------------------------------------------------------------------------------
 
@@ -467,10 +483,12 @@ compareG f u v = unsafePerformIO $ do
 compareD = compareG c_compareD
 compareF = compareG c_compareF
 compareI = compareG c_compareI
+compareL = compareG c_compareL
 
 foreign import ccall unsafe "compareD" c_compareD :: CV Double (CV Double (CV CInt (IO CInt)))
 foreign import ccall unsafe "compareF" c_compareF :: CV Float (CV Float  (CV CInt (IO CInt)))
 foreign import ccall unsafe "compareI" c_compareI :: CV CInt (CV CInt   (CV CInt (IO CInt)))
+foreign import ccall unsafe "compareL" c_compareL :: Z :> Z :> I :> Ok
 
 --------------------------------------------------------------------------------
 
@@ -482,6 +500,7 @@ selectG f c u v w = unsafePerformIO $ do
 selectD = selectG c_selectD
 selectF = selectG c_selectF
 selectI = selectG c_selectI
+selectL = selectG c_selectL
 selectC = selectG c_selectC
 selectQ = selectG c_selectQ
 
@@ -492,6 +511,7 @@ foreign import ccall unsafe "chooseF" c_selectF :: Sel Float
 foreign import ccall unsafe "chooseI" c_selectI :: Sel CInt
 foreign import ccall unsafe "chooseC" c_selectC :: Sel (Complex Double)
 foreign import ccall unsafe "chooseQ" c_selectQ :: Sel (Complex Float)
+foreign import ccall unsafe "chooseL" c_selectL :: Sel Z
 
 ---------------------------------------------------------------------------
 
@@ -503,6 +523,7 @@ remapG f i j m = unsafePerformIO $ do
 remapD = remapG c_remapD
 remapF = remapG c_remapF
 remapI = remapG c_remapI
+remapL = remapG c_remapL
 remapC = remapG c_remapC
 remapQ = remapG c_remapQ
 
@@ -513,6 +534,7 @@ foreign import ccall unsafe "remapF" c_remapF :: Rem Float
 foreign import ccall unsafe "remapI" c_remapI :: Rem CInt
 foreign import ccall unsafe "remapC" c_remapC :: Rem (Complex Double)
 foreign import ccall unsafe "remapQ" c_remapQ :: Rem (Complex Float)
+foreign import ccall unsafe "remapL" c_remapL :: Rem Z
 
 --------------------------------------------------------------------------------
 
diff --git a/packages/base/src/Internal/Numeric.hs b/packages/base/src/Internal/Numeric.hs
index 879daf8..85594cc 100644
--- a/packages/base/src/Internal/Numeric.hs
+++ b/packages/base/src/Internal/Numeric.hs
@@ -24,7 +24,7 @@ import Internal.Element
 import Internal.ST as ST
 import Internal.Conversion
 import Internal.Vectorized
-import Internal.LAPACK(multiplyR,multiplyC,multiplyF,multiplyQ,multiplyI)
+import Internal.LAPACK(multiplyR,multiplyC,multiplyF,multiplyQ,multiplyI,multiplyL)
 import Data.List.Split(chunksOf)
 
 --------------------------------------------------------------------------------
@@ -129,6 +129,45 @@ instance Container Vector I
     fromInt' = id
     toInt'   = id
 
+
+instance Container Vector Z
+  where
+    conj' = id
+    size' = dim
+    scale' = vectorMapValL Scale
+    addConstant = vectorMapValL AddConstant
+    add = vectorZipL Add
+    sub = vectorZipL Sub
+    mul = vectorZipL Mul
+    equal u v = dim u == dim v && maxElement' (vectorMapL Abs (sub u v)) == 0
+    scalar' x = fromList [x]
+    konst' = constantD
+    build' = buildV
+    cmap' = mapVector
+    atIndex' = (@>)
+    minIndex'     = emptyErrorV "minIndex"   (fromIntegral . toScalarL MinIdx)
+    maxIndex'     = emptyErrorV "maxIndex"   (fromIntegral . toScalarL MaxIdx)
+    minElement'   = emptyErrorV "minElement" (toScalarL Min)
+    maxElement'   = emptyErrorV "maxElement" (toScalarL Max)
+    sumElements'  = sumL
+    prodElements' = prodL
+    step' = stepL
+    find' = findV
+    assoc' = assocV
+    accum' = accumV
+    ccompare' = compareCV compareV
+    cselect' = selectCV selectV
+    scaleRecip = undefined -- cannot match
+    divide = undefined
+    arctan2' = undefined
+    cmod' m x
+        | m /= 0    = vectorMapValL ModVS m x
+        | otherwise = error $ "cmod 0 on vector of size "++(show $ dim x)
+    fromInt' = int2longV
+    toInt'   = long2intV
+
+
+
 instance Container Vector Float
   where
     conj' = id
@@ -540,6 +579,13 @@ instance Product I where
     normInf    = emptyVal (maxElement . vectorMapI Abs)
     multiply   = emptyMul multiplyI
 
+instance Product Z where
+    norm2      = undefined
+    absSum     = emptyVal (sumElements . vectorMapL Abs)
+    norm1      = absSum
+    normInf    = emptyVal (maxElement . vectorMapL Abs)
+    multiply   = emptyMul multiplyL
+
 
 emptyMul m a b
     | x1 == 0 && x2 == 0 || r == 0 || c == 0 = konst' 0 (r,c)
@@ -676,6 +722,7 @@ type instance RealOf Float = Float
 type instance RealOf (Complex Float) = Float
 
 type instance RealOf I = I
+type instance RealOf Z = Z
 
 type family ComplexOf x
 
diff --git a/packages/base/src/Internal/Vectorized.hs b/packages/base/src/Internal/Vectorized.hs
index b9b8239..b1ad424 100644
--- a/packages/base/src/Internal/Vectorized.hs
+++ b/packages/base/src/Internal/Vectorized.hs
@@ -98,6 +98,8 @@ sumC = sumg c_sumC
 sumI :: Vector CInt -> CInt
 sumI = sumg c_sumI
 
+sumL = sumg c_sumL
+
 sumg f x = unsafePerformIO $ do
     r <- createVector 1
     app2 f vec x vec r "sum"
@@ -110,6 +112,7 @@ foreign import ccall unsafe "sumR" c_sumR :: TVV Double
 foreign import ccall unsafe "sumQ" c_sumQ :: TVV (Complex Float)
 foreign import ccall unsafe "sumC" c_sumC :: TVV (Complex Double)
 foreign import ccall unsafe "sumI" c_sumI :: TVV CInt
+foreign import ccall unsafe "sumL" c_sumL :: TVV Z
 
 -- | product of elements
 prodF :: Vector Float -> Float
@@ -131,6 +134,7 @@ prodC = prodg c_prodC
 prodI :: Vector CInt -> CInt
 prodI = prodg c_prodI
 
+prodL = prodg c_prodL
 
 prodg f x = unsafePerformIO $ do
     r <- createVector 1
@@ -143,6 +147,7 @@ foreign import ccall unsafe "prodR" c_prodR :: TVV Double
 foreign import ccall unsafe "prodQ" c_prodQ :: TVV (Complex Float)
 foreign import ccall unsafe "prodC" c_prodC :: TVV (Complex Double)
 foreign import ccall unsafe "prodI" c_prodI :: TVV (CInt)
+foreign import ccall unsafe "prodL" c_prodL :: TVV Z
 
 ------------------------------------------------------------------
 
@@ -200,6 +205,13 @@ toScalarI oper =  toScalarAux c_toScalarI (fromei oper)
 
 foreign import ccall unsafe "toScalarI" c_toScalarI :: CInt -> TVV CInt
 
+-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
+toScalarL :: FunCodeS -> Vector Z -> Z
+toScalarL oper =  toScalarAux c_toScalarL (fromei oper)
+
+foreign import ccall unsafe "toScalarL" c_toScalarL :: CInt -> TVV Z
+
+
 ------------------------------------------------------------------
 
 -- | map of real vectors with given function
@@ -232,6 +244,12 @@ vectorMapI = vectorMapAux c_vectorMapI
 
 foreign import ccall unsafe "mapI" c_vectorMapI :: CInt -> TVV CInt
 
+-- | map of real vectors with given function
+vectorMapL :: FunCodeV -> Vector Z -> Vector Z
+vectorMapL = vectorMapAux c_vectorMapL
+
+foreign import ccall unsafe "mapL" c_vectorMapL :: CInt -> TVV Z
+
 -------------------------------------------------------------------
 
 -- | map of real vectors with given function
@@ -264,6 +282,12 @@ vectorMapValI oper = vectorMapValAux c_vectorMapValI (fromei oper)
 
 foreign import ccall unsafe "mapValI" c_vectorMapValI :: CInt -> Ptr CInt -> TVV CInt
 
+-- | map of real vectors with given function
+vectorMapValL :: FunCodeSV -> Z -> Vector Z -> Vector Z
+vectorMapValL oper = vectorMapValAux c_vectorMapValL (fromei oper)
+
+foreign import ccall unsafe "mapValL" c_vectorMapValL :: CInt -> Ptr Z -> TVV Z
+
 
 -------------------------------------------------------------------
 
@@ -299,6 +323,11 @@ vectorZipI = vectorZipAux c_vectorZipI
 
 foreign import ccall unsafe "zipI" c_vectorZipI :: CInt -> TVVV CInt
 
+-- | elementwise operation on CInt vectors
+vectorZipL :: FunCodeVV -> Vector Z -> Vector Z -> Vector Z
+vectorZipL = vectorZipAux c_vectorZipL
+
+foreign import ccall unsafe "zipL" c_vectorZipL :: CInt -> TVVV Z
 
 --------------------------------------------------------------------------------
 
@@ -385,6 +414,12 @@ float2IntV = tog c_float2int
 int2floatV :: Vector CInt -> Vector Float
 int2floatV = tog c_int2float
 
+int2longV :: Vector I -> Vector Z
+int2longV = tog c_int2long
+
+long2intV :: Vector Z -> Vector I
+long2intV = tog c_long2int
+
 
 tog f v = unsafePerformIO $ do
     r <- createVector (dim v)
@@ -397,6 +432,8 @@ foreign import ccall unsafe "int2double"   c_int2double   :: CInt :> Double :> O
 foreign import ccall unsafe "double2int"   c_double2int   :: Double :> CInt :> Ok
 foreign import ccall unsafe "int2float"    c_int2float    :: CInt :> Float :> Ok
 foreign import ccall unsafe "float2int"    c_float2int    :: Float :> CInt :> Ok
+foreign import ccall unsafe "int2long"    c_int2long    :: I :> Z :> Ok
+foreign import ccall unsafe "long2int"    c_long2int    :: Z :> I :> Ok
 
 
 ---------------------------------------------------------------
@@ -415,10 +452,14 @@ stepF = stepg c_stepF
 stepI :: Vector CInt -> Vector CInt
 stepI = stepg c_stepI
 
+stepL :: Vector Z -> Vector Z
+stepL = stepg c_stepL
+
+
 foreign import ccall unsafe "stepF" c_stepF :: TVV Float
 foreign import ccall unsafe "stepD" c_stepD :: TVV Double
 foreign import ccall unsafe "stepI" c_stepI :: TVV CInt
-
+foreign import ccall unsafe "stepL" c_stepL :: TVV Z
 
 --------------------------------------------------------------------------------
 
@@ -461,6 +502,7 @@ foreign import ccall unsafe "constantR" cconstantR :: TConst Double
 foreign import ccall unsafe "constantQ" cconstantQ :: TConst (Complex Float)
 foreign import ccall unsafe "constantC" cconstantC :: TConst (Complex Double)
 foreign import ccall unsafe "constantI" cconstantI :: TConst CInt
+foreign import ccall unsafe "constantL" cconstantL :: TConst Z
 
 ----------------------------------------------------------------------