module Bindings.LibLinear where
import Foreign.Ptr (Ptr,FunPtr,plusPtr)
import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)
import Foreign.Storable
import Foreign.C.Types
import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)
import Foreign.Marshal.Alloc (alloca)
import Foreign.Marshal.Array (peekArray,pokeArray)
import Data.Int
import Data.Word
data C'feature_node = C'feature_node{
c'feature_node'index :: CInt,
c'feature_node'value :: CDouble
} deriving (Eq,Show)
p'feature_node'index p = plusPtr p 0
p'feature_node'index :: Ptr (C'feature_node) -> Ptr (CInt)
p'feature_node'value p = plusPtr p 4
p'feature_node'value :: Ptr (C'feature_node) -> Ptr (CDouble)
instance Storable C'feature_node where
sizeOf _ = 12
alignment = sizeOf
peek p = do
v0 <- peekByteOff p 0
v1 <- peekByteOff p 4
return $ C'feature_node v0 v1
poke p (C'feature_node v0 v1) = do
pokeByteOff p 0 v0
pokeByteOff p 4 v1
return ()
data C'problem = C'problem{
c'problem'l :: CInt,
c'problem'n :: CInt,
c'problem'y :: Ptr CInt,
c'problem'x :: Ptr (Ptr C'feature_node),
c'problem'bias :: CDouble
} deriving (Eq,Show)
p'problem'l p = plusPtr p 0
p'problem'l :: Ptr (C'problem) -> Ptr (CInt)
p'problem'n p = plusPtr p 4
p'problem'n :: Ptr (C'problem) -> Ptr (CInt)
p'problem'y p = plusPtr p 8
p'problem'y :: Ptr (C'problem) -> Ptr (Ptr CInt)
p'problem'x p = plusPtr p 12
p'problem'x :: Ptr (C'problem) -> Ptr (Ptr (Ptr C'feature_node))
p'problem'bias p = plusPtr p 16
p'problem'bias :: Ptr (C'problem) -> Ptr (CDouble)
instance Storable C'problem where
sizeOf _ = 24
alignment = sizeOf
peek p = do
v0 <- peekByteOff p 0
v1 <- peekByteOff p 4
v2 <- peekByteOff p 8
v3 <- peekByteOff p 12
v4 <- peekByteOff p 16
return $ C'problem v0 v1 v2 v3 v4
poke p (C'problem v0 v1 v2 v3 v4) = do
pokeByteOff p 0 v0
pokeByteOff p 4 v1
pokeByteOff p 8 v2
pokeByteOff p 12 v3
pokeByteOff p 16 v4
return ()
c'L2R_LR = 0
c'L2R_LR :: (Num a) => a
c'L2R_L2LOSS_SVC_DUAL = 1
c'L2R_L2LOSS_SVC_DUAL :: (Num a) => a
c'L2R_L2LOSS_SVC = 2
c'L2R_L2LOSS_SVC :: (Num a) => a
c'L2R_L1LOSS_SVC_DUAL = 3
c'L2R_L1LOSS_SVC_DUAL :: (Num a) => a
c'MCSVM_CS = 4
c'MCSVM_CS :: (Num a) => a
c'L1R_L2LOSS_SVC = 5
c'L1R_L2LOSS_SVC :: (Num a) => a
c'L1R_LR = 6
c'L1R_LR :: (Num a) => a
c'L2R_LR_DUAL = 7
c'L2R_LR_DUAL :: (Num a) => a
data C'parameter = C'parameter{
c'parameter'solver_type :: CInt,
c'parameter'eps :: CDouble,
c'parameter'C :: CDouble,
c'parameter'nr_weight :: CInt,
c'parameter'weight_label :: Ptr CInt,
c'parameter'weight :: Ptr CDouble
} deriving (Eq,Show)
p'parameter'solver_type p = plusPtr p 0
p'parameter'solver_type :: Ptr (C'parameter) -> Ptr (CInt)
p'parameter'eps p = plusPtr p 4
p'parameter'eps :: Ptr (C'parameter) -> Ptr (CDouble)
p'parameter'C p = plusPtr p 12
p'parameter'C :: Ptr (C'parameter) -> Ptr (CDouble)
p'parameter'nr_weight p = plusPtr p 20
p'parameter'nr_weight :: Ptr (C'parameter) -> Ptr (CInt)
p'parameter'weight_label p = plusPtr p 24
p'parameter'weight_label :: Ptr (C'parameter) -> Ptr (Ptr CInt)
p'parameter'weight p = plusPtr p 28
p'parameter'weight :: Ptr (C'parameter) -> Ptr (Ptr CDouble)
instance Storable C'parameter where
sizeOf _ = 32
alignment = sizeOf
peek p = do
v0 <- peekByteOff p 0
v1 <- peekByteOff p 4
v2 <- peekByteOff p 12
v3 <- peekByteOff p 20
v4 <- peekByteOff p 24
v5 <- peekByteOff p 28
return $ C'parameter v0 v1 v2 v3 v4 v5
poke p (C'parameter v0 v1 v2 v3 v4 v5) = do
pokeByteOff p 0 v0
pokeByteOff p 4 v1
pokeByteOff p 12 v2
pokeByteOff p 20 v3
pokeByteOff p 24 v4
pokeByteOff p 28 v5
return ()
data C'model = C'model{
c'model'param :: C'parameter,
c'model'nr_class :: CInt,
c'model'nr_feature :: CInt,
c'model'w :: Ptr CDouble,
c'model'label :: Ptr CInt,
c'model'bias :: CDouble
} deriving (Eq,Show)
p'model'param p = plusPtr p 0
p'model'param :: Ptr (C'model) -> Ptr (C'parameter)
p'model'nr_class p = plusPtr p 32
p'model'nr_class :: Ptr (C'model) -> Ptr (CInt)
p'model'nr_feature p = plusPtr p 36
p'model'nr_feature :: Ptr (C'model) -> Ptr (CInt)
p'model'w p = plusPtr p 40
p'model'w :: Ptr (C'model) -> Ptr (Ptr CDouble)
p'model'label p = plusPtr p 44
p'model'label :: Ptr (C'model) -> Ptr (Ptr CInt)
p'model'bias p = plusPtr p 48
p'model'bias :: Ptr (C'model) -> Ptr (CDouble)
instance Storable C'model where
sizeOf _ = 56
alignment = sizeOf
peek p = do
v0 <- peekByteOff p 0
v1 <- peekByteOff p 32
v2 <- peekByteOff p 36
v3 <- peekByteOff p 40
v4 <- peekByteOff p 44
v5 <- peekByteOff p 48
return $ C'model v0 v1 v2 v3 v4 v5
poke p (C'model v0 v1 v2 v3 v4 v5) = do
pokeByteOff p 0 v0
pokeByteOff p 32 v1
pokeByteOff p 36 v2
pokeByteOff p 40 v3
pokeByteOff p 44 v4
pokeByteOff p 48 v5
return ()
foreign import ccall "train" c'train
:: Ptr C'problem -> Ptr C'parameter -> IO (Ptr C'model)
foreign import ccall "&train" p'train
:: FunPtr (Ptr C'problem -> Ptr C'parameter -> IO (Ptr C'model))
foreign import ccall "cross_validation" c'cross_validation
:: Ptr C'problem -> Ptr C'parameter -> CInt -> Ptr CDouble -> IO ()
foreign import ccall "&cross_validation" p'cross_validation
:: FunPtr (Ptr C'problem -> Ptr C'parameter -> CInt -> Ptr CDouble -> IO ())
foreign import ccall "save_model" c'save_model
:: CString -> Ptr C'model -> IO ()
foreign import ccall "&save_model" p'save_model
:: FunPtr (CString -> Ptr C'model -> IO ())
foreign import ccall "load_model" c'load_model
:: CString -> IO (Ptr C'model)
foreign import ccall "&load_model" p'load_model
:: FunPtr (CString -> IO (Ptr C'model))
foreign import ccall "get_nr_feature" c'get_nr_feature
:: Ptr C'model -> IO CInt
foreign import ccall "&get_nr_feature" p'get_nr_feature
:: FunPtr (Ptr C'model -> IO CInt)
foreign import ccall "get_nr_class" c'get_nr_class
:: Ptr C'model -> IO CInt
foreign import ccall "&get_nr_class" p'get_nr_class
:: FunPtr (Ptr C'model -> IO CInt)
foreign import ccall "get_labels" c'get_labels
:: Ptr C'model -> Ptr CInt -> IO ()
foreign import ccall "&get_labels" p'get_labels
:: FunPtr (Ptr C'model -> Ptr CInt -> IO ())
foreign import ccall "predict_values" c'predict_values
:: Ptr C'model -> Ptr C'feature_node -> Ptr CDouble -> IO CInt
foreign import ccall "&predict_values" p'predict_values
:: FunPtr (Ptr C'model -> Ptr C'feature_node -> Ptr CDouble -> IO CInt)
foreign import ccall "predict" c'predict
:: Ptr C'model -> Ptr C'feature_node -> IO CInt
foreign import ccall "&predict" p'predict
:: FunPtr (Ptr C'model -> Ptr C'feature_node -> IO CInt)
foreign import ccall "predict_probability" c'predict_probability
:: Ptr C'model -> Ptr C'feature_node -> Ptr CDouble -> IO CInt
foreign import ccall "&predict_probability" p'predict_probability
:: FunPtr (Ptr C'model -> Ptr C'feature_node -> Ptr CDouble -> IO CInt)
foreign import ccall "free_model_content" c'free_model_content
:: Ptr C'model -> IO ()
foreign import ccall "&free_model_content" p'free_model_content
:: FunPtr (Ptr C'model -> IO ())
foreign import ccall "free_and_destroy_model" c'free_and_destroy_model
:: Ptr (Ptr C'model) -> IO ()
foreign import ccall "&free_and_destroy_model" p'free_and_destroy_model
:: FunPtr (Ptr (Ptr C'model) -> IO ())
foreign import ccall "destroy_param" c'destroy_param
:: Ptr C'parameter -> IO ()
foreign import ccall "&destroy_param" p'destroy_param
:: FunPtr (Ptr C'parameter -> IO ())
foreign import ccall "check_parameter" c'check_parameter
:: Ptr C'problem -> Ptr C'parameter -> IO CString
foreign import ccall "&check_parameter" p'check_parameter
:: FunPtr (Ptr C'problem -> Ptr C'parameter -> IO CString)
foreign import ccall "check_probability_model" c'check_probability_model
:: Ptr C'model -> IO CInt
foreign import ccall "&check_probability_model" p'check_probability_model
:: FunPtr (Ptr C'model -> IO CInt)