{-# LINE 1 "./QuantLib/Commodity.chs" #-}
module QuantLib.Commodity
(
CommodityType
, UnitOfMeasure
, UnitOfMeasureType(..)
, PaymentTerm
, PaymentTermEventType(..)
, Quantity
, CommodityUnitCost
, DateInterval
, PricingPeriod
, PricingPeriods
, UnitOfMeasureConversion
, UnitOfMeasureConversionType(..)
, commodityType
, nullCommodityType
, unitOfMeasure
, lotUnitOfMeasure
, barrelUnitOfMeasure
, mtUnitOfMeasure
, mbUnitOfMeasure
, gallonUnitOfMeasure
, litreUnitOfMeasure
, kilolitreUnitOfMeasure
, tokyoKilolitreUnitOfMeasure
, paymentTerm
, pricingPeriod
, unitOfMeasureConversion
, addUomConversion
, clearUomConversions
, setCommoditySettingsCurrency
, setCommoditySettingsUnitOfMeasure
, roundedQuantity
, closeQuantity
, closeEnoughQuantity
, isDateBetween
, intersection
, convertQuantity
, chainUnitOfMeasureConversion
, commodityTypeCode
, commodityTypeName
, commodityTypeEmpty
, unitOfMeasureName
, unitOfMeasureCode
, unitOfMeasureType
, unitOfMeasureEmpty
, paymentTermName
, paymentTermEventType
, paymentTermOffsetDays
, paymentTermCalendar
, paymentTermEmpty
, paymentTermPaymentDate
, pricingPeriodStartDate
, pricingPeriodEndDate
, pricingPeriodPaymentDate
, pricingPeriodQuantity
, unitOfMeasureConversionSource
, unitOfMeasureConversionTarget
, unitOfMeasureConversionCommodityType
, unitOfMeasureConversionType
, unitOfMeasureConversionFactor
, unitOfMeasureConversionCode
, lookupUomConversion
, commoditySettingsCurrency
, commoditySettingsUnitOfMeasure
) where
import qualified Foreign.C.String as C2HSImp
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.ForeignPtr as C2HSImp
import qualified Foreign.Marshal.Utils as C2HSImp
import qualified Foreign.Ptr as C2HSImp
import qualified System.IO.Unsafe as C2HSImp
import Control.Exception (mask_)
import System.IO.Unsafe (unsafePerformIO)
import QuantLib.Internal
import QuantLib.Internal.Type
import QuantLib.Internal.Common
import Foreign.Marshal.Alloc(alloca)
{-# LINE 100 "./QuantLib/Commodity.chs" #-}
{-# LINE 101 "./QuantLib/Commodity.chs" #-}
{-# LINE 102 "./QuantLib/Commodity.chs" #-}
{-# LINE 103 "./QuantLib/Commodity.chs" #-}
{-# LINE 104 "./QuantLib/Commodity.chs" #-}
{-# LINE 105 "./QuantLib/Commodity.chs" #-}
data UnitOfMeasureConversionType = UomDirect
| UomDerived
deriving (Enum,Show,Eq,Read)
{-# LINE 107 "./QuantLib/Commodity.chs" #-}
commodityType :: (String)
-> (String)
-> IO ((CommodityType))
commodityType :: String -> String -> IO CommodityType
commodityType String
a1 String
a2 =
String -> (CString -> IO CommodityType) -> IO CommodityType
forall a. String -> (CString -> IO a) -> IO a
C2HSImp.withCString String
a1 ((CString -> IO CommodityType) -> IO CommodityType)
-> (CString -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \CString
a1' ->
String -> (CString -> IO CommodityType) -> IO CommodityType
forall a. String -> (CString -> IO a) -> IO a
C2HSImp.withCString String
a2 ((CString -> IO CommodityType) -> IO CommodityType)
-> (CString -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \CString
a2' ->
(Ptr (Ptr ()) -> IO CommodityType) -> IO CommodityType
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO CommodityType) -> IO CommodityType)
-> (Ptr (Ptr ()) -> IO CommodityType) -> IO CommodityType
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a3' ->
CString -> CString -> Ptr (Ptr ()) -> IO (Ptr CCommodityType)
commodityType'_ CString
a1' CString
a2' Ptr (Ptr ())
a3' IO (Ptr CCommodityType)
-> (Ptr CCommodityType -> IO CommodityType) -> IO CommodityType
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CCommodityType
res ->
Ptr CCommodityType -> IO CommodityType
peekCommodityType Ptr CCommodityType
res IO CommodityType
-> (CommodityType -> IO CommodityType) -> IO CommodityType
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CommodityType
res' ->
Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck Ptr (Ptr ())
a3'IO () -> IO CommodityType -> IO CommodityType
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
CommodityType -> IO CommodityType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (CommodityType
res')
{-# LINE 114 "./QuantLib/Commodity.chs" #-}
nullCommodityType :: IO ((CommodityType))
nullCommodityType =
preErrorCheck $ \a1' ->
nullCommodityType'_ a1' >>= \res ->
peekCommodityType res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 118 "./QuantLib/Commodity.chs" #-}
commodityTypeCode :: CommodityType -> String
commodityTypeCode x = unsafePerformIO $ mask_ (commodityTypeCodeRaw x)
commodityTypeCodeRaw :: (CommodityType) -> IO ((String))
commodityTypeCodeRaw a1 =
withCommodityType a1 $ \a1' ->
commodityTypeCodeRaw'_ a1' >>= \res ->
peekDynString res >>= \res' ->
return (res')
{-# LINE 123 "./QuantLib/Commodity.chs" #-}
commodityTypeName :: CommodityType -> String
commodityTypeName x = unsafePerformIO $ mask_ (commodityTypeNameRaw x)
commodityTypeNameRaw :: (CommodityType) -> IO ((String))
commodityTypeNameRaw a1 =
withCommodityType a1 $ \a1' ->
commodityTypeNameRaw'_ a1' >>= \res ->
peekDynString res >>= \res' ->
return (res')
{-# LINE 128 "./QuantLib/Commodity.chs" #-}
commodityTypeEmpty :: (CommodityType) -> (Bool)
commodityTypeEmpty a1 =
C2HSImp.unsafePerformIO $
withCommodityType a1 $ \a1' ->
commodityTypeEmpty'_ a1' >>= \res ->
let {res' = C2HSImp.toBool res} in
return (res')
{-# LINE 131 "./QuantLib/Commodity.chs" #-}
unitOfMeasure :: (String)
-> (String)
-> (UnitOfMeasureType) -> IO ((UnitOfMeasure))
unitOfMeasure a1 a2 a3 =
C2HSImp.withCString a1 $ \a1' ->
C2HSImp.withCString a2 $ \a2' ->
let {a3' = fromEnumC a3} in
preErrorCheck $ \a4' ->
unitOfMeasure'_ a1' a2' a3' a4' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a4'>>
return (res')
{-# LINE 138 "./QuantLib/Commodity.chs" #-}
unitOfMeasureName :: UnitOfMeasure -> String
unitOfMeasureName x = unsafePerformIO $ mask_ (unitOfMeasureNameRaw x)
unitOfMeasureNameRaw :: (UnitOfMeasure) -> IO ((String))
unitOfMeasureNameRaw a1 =
withUnitOfMeasure a1 $ \a1' ->
unitOfMeasureNameRaw'_ a1' >>= \res ->
peekDynString res >>= \res' ->
return (res')
{-# LINE 143 "./QuantLib/Commodity.chs" #-}
unitOfMeasureCode :: UnitOfMeasure -> String
unitOfMeasureCode x = unsafePerformIO $ mask_ (unitOfMeasureCodeRaw x)
unitOfMeasureCodeRaw :: (UnitOfMeasure) -> IO ((String))
unitOfMeasureCodeRaw a1 =
withUnitOfMeasure a1 $ \a1' ->
unitOfMeasureCodeRaw'_ a1' >>= \res ->
peekDynString res >>= \res' ->
return (res')
{-# LINE 148 "./QuantLib/Commodity.chs" #-}
unitOfMeasureType :: (UnitOfMeasure) -> (UnitOfMeasureType)
unitOfMeasureType a1 =
C2HSImp.unsafePerformIO $
withUnitOfMeasure a1 $ \a1' ->
unitOfMeasureType'_ a1' >>= \res ->
let {res' = toEnumC res} in
return (res')
{-# LINE 151 "./QuantLib/Commodity.chs" #-}
unitOfMeasureEmpty :: (UnitOfMeasure) -> (Bool)
unitOfMeasureEmpty a1 =
C2HSImp.unsafePerformIO $
withUnitOfMeasure a1 $ \a1' ->
unitOfMeasureEmpty'_ a1' >>= \res ->
let {res' = C2HSImp.toBool res} in
return (res')
{-# LINE 154 "./QuantLib/Commodity.chs" #-}
lotUnitOfMeasure :: IO ((UnitOfMeasure))
lotUnitOfMeasure =
preErrorCheck $ \a1' ->
lotUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 157 "./QuantLib/Commodity.chs" #-}
barrelUnitOfMeasure :: IO ((UnitOfMeasure))
barrelUnitOfMeasure =
preErrorCheck $ \a1' ->
barrelUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 160 "./QuantLib/Commodity.chs" #-}
mtUnitOfMeasure :: IO ((UnitOfMeasure))
mtUnitOfMeasure =
preErrorCheck $ \a1' ->
mtUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 163 "./QuantLib/Commodity.chs" #-}
mbUnitOfMeasure :: IO ((UnitOfMeasure))
mbUnitOfMeasure =
preErrorCheck $ \a1' ->
mbUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 166 "./QuantLib/Commodity.chs" #-}
gallonUnitOfMeasure :: IO ((UnitOfMeasure))
gallonUnitOfMeasure =
preErrorCheck $ \a1' ->
gallonUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 169 "./QuantLib/Commodity.chs" #-}
litreUnitOfMeasure :: IO ((UnitOfMeasure))
litreUnitOfMeasure =
preErrorCheck $ \a1' ->
litreUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 172 "./QuantLib/Commodity.chs" #-}
kilolitreUnitOfMeasure :: IO ((UnitOfMeasure))
kilolitreUnitOfMeasure =
preErrorCheck $ \a1' ->
kilolitreUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 175 "./QuantLib/Commodity.chs" #-}
tokyoKilolitreUnitOfMeasure :: IO ((UnitOfMeasure))
tokyoKilolitreUnitOfMeasure =
preErrorCheck $ \a1' ->
tokyoKilolitreUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 178 "./QuantLib/Commodity.chs" #-}
paymentTerm :: (String)
-> (PaymentTermEventType) -> (Int)
-> (Calendar) -> IO ((PaymentTerm))
paymentTerm a1 a2 a3 a4 =
C2HSImp.withCString a1 $ \a1' ->
let {a2' = fromEnumC a2} in
let {a3' = fromIntegral a3} in
withCalendar a4 $ \a4' ->
preErrorCheck $ \a5' ->
paymentTerm'_ a1' a2' a3' a4' a5' >>= \res ->
peekPaymentTerm res >>= \res' ->
errorCheck a5'>>
return (res')
{-# LINE 186 "./QuantLib/Commodity.chs" #-}
paymentTermName :: PaymentTerm -> String
paymentTermName x = unsafePerformIO $ mask_ (paymentTermNameRaw x)
paymentTermNameRaw :: (PaymentTerm) -> IO ((String))
paymentTermNameRaw a1 =
withPaymentTerm a1 $ \a1' ->
paymentTermNameRaw'_ a1' >>= \res ->
peekDynString res >>= \res' ->
return (res')
{-# LINE 191 "./QuantLib/Commodity.chs" #-}
paymentTermEventType :: (PaymentTerm) -> (PaymentTermEventType)
paymentTermEventType a1 =
C2HSImp.unsafePerformIO $
withPaymentTerm a1 $ \a1' ->
paymentTermEventType'_ a1' >>= \res ->
let {res' = toEnumC res} in
return (res')
{-# LINE 194 "./QuantLib/Commodity.chs" #-}
paymentTermOffsetDays :: (PaymentTerm) -> (Int)
paymentTermOffsetDays a1 =
C2HSImp.unsafePerformIO $
withPaymentTerm a1 $ \a1' ->
paymentTermOffsetDays'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
{-# LINE 197 "./QuantLib/Commodity.chs" #-}
paymentTermCalendar :: (PaymentTerm) -> IO ((Calendar))
paymentTermCalendar a1 =
withPaymentTerm a1 $ \a1' ->
preErrorCheck $ \a2' ->
paymentTermCalendar'_ a1' a2' >>= \res ->
peekCalendar res >>= \res' ->
errorCheck a2'>>
return (res')
{-# LINE 200 "./QuantLib/Commodity.chs" #-}
paymentTermEmpty :: (PaymentTerm) -> (Bool)
paymentTermEmpty a1 =
C2HSImp.unsafePerformIO $
withPaymentTerm a1 $ \a1' ->
paymentTermEmpty'_ a1' >>= \res ->
let {res' = C2HSImp.toBool res} in
return (res')
{-# LINE 203 "./QuantLib/Commodity.chs" #-}
paymentTermPaymentDate :: (PaymentTerm) -> (Day) -> IO ((Day))
paymentTermPaymentDate a1 a2 =
withPaymentTerm a1 $ \a1' ->
withDay a2 $ \a2' ->
preErrorCheck $ \a3' ->
paymentTermPaymentDate'_ a1' a2' a3' >>= \res ->
let {res' = toDay res} in
errorCheck a3'>>
return (res')
{-# LINE 208 "./QuantLib/Commodity.chs" #-}
type Quantity = (CommodityType, UnitOfMeasure, Double)
quantityRoundedAmount :: (UnitOfMeasure) -> (Double) -> (Double)
quantityRoundedAmount a1 a2 =
C2HSImp.unsafePerformIO $
withUnitOfMeasure a1 $ \a1' ->
let {a2' = realToFrac a2} in
quantityRoundedAmount'_ a1' a2' >>= \res ->
let {res' = realToFrac res} in
return (res')
{-# LINE 214 "./QuantLib/Commodity.chs" #-}
roundedQuantity :: Quantity -> Quantity
roundedQuantity (ct, uom, amount) = (ct, uom, quantityRoundedAmount uom amount)
qlQuantityClose_ :: (CommodityType) -> (UnitOfMeasure) -> (Double) -> (CommodityType) -> (UnitOfMeasure) -> (Double) -> (Int) -> IO ((Bool))
qlQuantityClose_ :: CommodityType
-> UnitOfMeasure
-> Double
-> CommodityType
-> UnitOfMeasure
-> Double
-> Int
-> IO Bool
qlQuantityClose_ CommodityType
a1 UnitOfMeasure
a2 Double
a3 CommodityType
a4 UnitOfMeasure
a5 Double
a6 Int
a7 =
CommodityType -> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a1 ((Ptr CCommodityType -> IO Bool) -> IO Bool)
-> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a1' ->
UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a2 ((Ptr CUnitOfMeasure -> IO Bool) -> IO Bool)
-> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a2' ->
let {a3' :: CDouble
a3' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a3} in
CommodityType -> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a4 ((Ptr CCommodityType -> IO Bool) -> IO Bool)
-> (Ptr CCommodityType -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a4' ->
UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a5 ((Ptr CUnitOfMeasure -> IO Bool) -> IO Bool)
-> (Ptr CUnitOfMeasure -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a5' ->
let {a6' :: CDouble
a6' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a6} in
let {a7' :: CInt
a7' = Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a7} in
(Ptr (Ptr ()) -> IO Bool) -> IO Bool
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO Bool) -> IO Bool)
-> (Ptr (Ptr ()) -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a8' ->
Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> CDouble
-> Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> CDouble
-> CInt
-> Ptr (Ptr ())
-> IO CInt
qlQuantityClose_'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' CDouble
a3' Ptr CCommodityType
a4' Ptr CUnitOfMeasure
a5' CDouble
a6' CInt
a7' Ptr (Ptr ())
a8' IO CInt -> (CInt -> IO Bool) -> IO Bool
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CInt
res ->
let {res' :: Bool
res' = CInt -> Bool
forall a. (Eq a, Num a) => a -> Bool
C2HSImp.toBool CInt
res} in
Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck Ptr (Ptr ())
a8'IO () -> IO Bool -> IO Bool
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
res')
{-# LINE 225 "./QuantLib/Commodity.chs" #-}
closeQuantity :: Quantity -> Quantity -> Int -> IO Bool
closeQuantity (ct1, uom1, amt1) (ct2, uom2, amt2) n = qlQuantityClose_ ct1 uom1 amt1 ct2 uom2 amt2 n
qlQuantityCloseEnough_ :: (CommodityType) -> (UnitOfMeasure) -> (Double) -> (CommodityType) -> (UnitOfMeasure) -> (Double) -> (Int) -> IO ((Bool))
qlQuantityCloseEnough_ a1 a2 a3 a4 a5 a6 a7 =
withCommodityType a1 $ \a1' ->
withUnitOfMeasure a2 $ \a2' ->
let {a3' = realToFrac a3} in
withCommodityType a4 $ \a4' ->
withUnitOfMeasure a5 $ \a5' ->
let {a6' = realToFrac a6} in
let {a7' = fromIntegral a7} in
preErrorCheck $ \a8' ->
qlQuantityCloseEnough_'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
let {res' = C2HSImp.toBool res} in
errorCheck a8'>>
return (res')
{-# LINE 236 "./QuantLib/Commodity.chs" #-}
closeEnoughQuantity :: Quantity -> Quantity -> Int -> IO Bool
closeEnoughQuantity (ct1, uom1, amt1) (ct2, uom2, amt2) n = qlQuantityCloseEnough_ ct1 uom1 amt1 ct2 uom2 amt2 n
type CommodityUnitCost = (Double, Currency, UnitOfMeasure)
type DateInterval = (Day, Day)
isDateBetween :: DateInterval
-> Day
-> Bool
-> Bool
-> Bool
isDateBetween :: DateInterval -> Day -> Bool -> Bool -> Bool
isDateBetween (Day
startDate, Day
endDate) Day
date Bool
includeFirst Bool
includeLast =
(if Bool
includeFirst then Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
>= Day
startDate else Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
> Day
startDate) Bool -> Bool -> Bool
&&
(if Bool
includeLast then Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
<= Day
endDate else Day
date Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
endDate)
intersection :: DateInterval -> DateInterval -> Maybe DateInterval
intersection :: DateInterval -> DateInterval -> Maybe DateInterval
intersection (Day
s1, Day
e1) (Day
s2, Day
e2)
| (Day
s1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
s2 Bool -> Bool -> Bool
&& Day
e1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
s2) Bool -> Bool -> Bool
|| (Day
s1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
> Day
e2 Bool -> Bool -> Bool
&& Day
e1 Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
> Day
e2) = Maybe DateInterval
forall a. Maybe a
Nothing
| Bool
otherwise = DateInterval -> Maybe DateInterval
forall a. a -> Maybe a
Just (Day -> Day -> Day
forall a. Ord a => a -> a -> a
max Day
s1 Day
s2, Day -> Day -> Day
forall a. Ord a => a -> a -> a
min Day
e1 Day
e2)
data PricingPeriod = PricingPeriod
{ PricingPeriod -> Day
pricingPeriodStartDate :: Day
, PricingPeriod -> Day
pricingPeriodEndDate :: Day
, PricingPeriod -> Day
pricingPeriodPaymentDate :: Day
, PricingPeriod -> Quantity
pricingPeriodQuantity :: Quantity
} deriving (Int -> PricingPeriod -> ShowS
[PricingPeriod] -> ShowS
PricingPeriod -> String
(Int -> PricingPeriod -> ShowS)
-> (PricingPeriod -> String)
-> ([PricingPeriod] -> ShowS)
-> Show PricingPeriod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PricingPeriod -> ShowS
showsPrec :: Int -> PricingPeriod -> ShowS
$cshow :: PricingPeriod -> String
show :: PricingPeriod -> String
$cshowList :: [PricingPeriod] -> ShowS
showList :: [PricingPeriod] -> ShowS
Show, PricingPeriod -> PricingPeriod -> Bool
(PricingPeriod -> PricingPeriod -> Bool)
-> (PricingPeriod -> PricingPeriod -> Bool) -> Eq PricingPeriod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PricingPeriod -> PricingPeriod -> Bool
== :: PricingPeriod -> PricingPeriod -> Bool
$c/= :: PricingPeriod -> PricingPeriod -> Bool
/= :: PricingPeriod -> PricingPeriod -> Bool
Eq)
type PricingPeriods = [PricingPeriod]
pricingPeriod :: Day -> Day -> Day -> Quantity -> PricingPeriod
pricingPeriod :: Day -> Day -> Day -> Quantity -> PricingPeriod
pricingPeriod Day
startDate Day
endDate
| Day
endDate Day -> Day -> Bool
forall a. Ord a => a -> a -> Bool
< Day
startDate = String -> Day -> Quantity -> PricingPeriod
forall a. HasCallStack => String -> a
error String
"pricingPeriod: end date must be >= start date"
| Bool
otherwise = Day -> Day -> Day -> Quantity -> PricingPeriod
PricingPeriod Day
startDate Day
endDate
unitOfMeasureConversion :: (CommodityType) -> (UnitOfMeasure)
-> (UnitOfMeasure)
-> (Double)
-> IO ((UnitOfMeasureConversion))
unitOfMeasureConversion :: CommodityType
-> UnitOfMeasure
-> UnitOfMeasure
-> Double
-> IO UnitOfMeasureConversion
unitOfMeasureConversion CommodityType
a1 UnitOfMeasure
a2 UnitOfMeasure
a3 Double
a4 =
CommodityType
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a1 ((Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a1' ->
UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a2 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a2' ->
UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a3 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a3' ->
let {a4' :: CDouble
a4' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
a4} in
(Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a5' ->
Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> Ptr CUnitOfMeasure
-> CDouble
-> Ptr (Ptr ())
-> IO (Ptr CUnitOfMeasureConversion)
unitOfMeasureConversion'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' Ptr CUnitOfMeasure
a3' CDouble
a4' Ptr (Ptr ())
a5' IO (Ptr CUnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CUnitOfMeasureConversion
res ->
Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion
peekUnitOfMeasureConversion Ptr CUnitOfMeasureConversion
res IO UnitOfMeasureConversion
-> (UnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UnitOfMeasureConversion
res' ->
Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck Ptr (Ptr ())
a5'IO () -> IO UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitOfMeasureConversion
res')
{-# LINE 295 "./QuantLib/Commodity.chs" #-}
unitOfMeasureConversionSource :: (UnitOfMeasureConversion) -> IO ((UnitOfMeasure))
unitOfMeasureConversionSource a1 =
withUnitOfMeasureConversion a1 $ \a1' ->
preErrorCheck $ \a2' ->
unitOfMeasureConversionSource'_ a1' a2' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a2'>>
return (res')
{-# LINE 298 "./QuantLib/Commodity.chs" #-}
unitOfMeasureConversionTarget :: (UnitOfMeasureConversion) -> IO ((UnitOfMeasure))
unitOfMeasureConversionTarget a1 =
withUnitOfMeasureConversion a1 $ \a1' ->
preErrorCheck $ \a2' ->
unitOfMeasureConversionTarget'_ a1' a2' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a2'>>
return (res')
{-# LINE 301 "./QuantLib/Commodity.chs" #-}
unitOfMeasureConversionCommodityType :: (UnitOfMeasureConversion) -> IO ((CommodityType))
unitOfMeasureConversionCommodityType a1 =
withUnitOfMeasureConversion a1 $ \a1' ->
preErrorCheck $ \a2' ->
unitOfMeasureConversionCommodityType'_ a1' a2' >>= \res ->
peekCommodityType res >>= \res' ->
errorCheck a2'>>
return (res')
{-# LINE 304 "./QuantLib/Commodity.chs" #-}
unitOfMeasureConversionType :: (UnitOfMeasureConversion) -> (UnitOfMeasureConversionType)
unitOfMeasureConversionType a1 =
C2HSImp.unsafePerformIO $
withUnitOfMeasureConversion a1 $ \a1' ->
unitOfMeasureConversionType'_ a1' >>= \res ->
let {res' = (toEnum . fromIntegral) res} in
return (res')
{-# LINE 307 "./QuantLib/Commodity.chs" #-}
unitOfMeasureConversionFactor :: (UnitOfMeasureConversion) -> (Double)
unitOfMeasureConversionFactor a1 =
C2HSImp.unsafePerformIO $
withUnitOfMeasureConversion a1 $ \a1' ->
unitOfMeasureConversionFactor'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
{-# LINE 310 "./QuantLib/Commodity.chs" #-}
unitOfMeasureConversionCode :: UnitOfMeasureConversion -> String
unitOfMeasureConversionCode x = unsafePerformIO $ mask_ (unitOfMeasureConversionCodeRaw x)
unitOfMeasureConversionCodeRaw :: (UnitOfMeasureConversion) -> IO ((String))
unitOfMeasureConversionCodeRaw a1 =
withUnitOfMeasureConversion a1 $ \a1' ->
unitOfMeasureConversionCodeRaw'_ a1' >>= \res ->
peekDynString res >>= \res' ->
return (res')
{-# LINE 315 "./QuantLib/Commodity.chs" #-}
qlUnitOfMeasureConversionConvert_ :: (UnitOfMeasureConversion) -> (CommodityType) -> (UnitOfMeasure) -> (Double) -> IO ((Double), (CommodityType), (UnitOfMeasure))
qlUnitOfMeasureConversionConvert_ a1 a2 a3 a4 =
withUnitOfMeasureConversion a1 $ \a1' ->
withCommodityType a2 $ \a2' ->
withUnitOfMeasure a3 $ \a3' ->
let {a4' = realToFrac a4} in
alloca $ \a5' ->
alloca $ \a6' ->
preErrorCheck $ \a7' ->
qlUnitOfMeasureConversionConvert_'_ a1' a2' a3' a4' a5' a6' a7' >>= \res ->
let {res' = realToFrac res} in
peekCommodityTypePtr a5'>>= \a5'' ->
peekUnitOfMeasurePtr a6'>>= \a6'' ->
errorCheck a7'>>
return (res', a5'', a6'')
{-# LINE 322 "./QuantLib/Commodity.chs" #-}
convertQuantity :: UnitOfMeasureConversion -> Quantity -> IO Quantity
convertQuantity conv (ct, uom, amount) = do
(amount', ct', uom') <- qlUnitOfMeasureConversionConvert_ conv ct uom amount
pure (ct', uom', amount')
chainUnitOfMeasureConversion :: (UnitOfMeasureConversion) -> (UnitOfMeasureConversion) -> IO ((UnitOfMeasureConversion))
chainUnitOfMeasureConversion :: UnitOfMeasureConversion
-> UnitOfMeasureConversion -> IO UnitOfMeasureConversion
chainUnitOfMeasureConversion UnitOfMeasureConversion
a1 UnitOfMeasureConversion
a2 =
UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b.
UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO b) -> IO b
withUnitOfMeasureConversion UnitOfMeasureConversion
a1 ((Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasureConversion
a1' ->
UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b.
UnitOfMeasureConversion
-> (Ptr CUnitOfMeasureConversion -> IO b) -> IO b
withUnitOfMeasureConversion UnitOfMeasureConversion
a2 ((Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasureConversion
a2' ->
(Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a3' ->
Ptr CUnitOfMeasureConversion
-> Ptr CUnitOfMeasureConversion
-> Ptr (Ptr ())
-> IO (Ptr CUnitOfMeasureConversion)
chainUnitOfMeasureConversion'_ Ptr CUnitOfMeasureConversion
a1' Ptr CUnitOfMeasureConversion
a2' Ptr (Ptr ())
a3' IO (Ptr CUnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CUnitOfMeasureConversion
res ->
Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion
peekUnitOfMeasureConversion Ptr CUnitOfMeasureConversion
res IO UnitOfMeasureConversion
-> (UnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UnitOfMeasureConversion
res' ->
Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck Ptr (Ptr ())
a3'IO () -> IO UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitOfMeasureConversion
res')
{-# LINE 337 "./QuantLib/Commodity.chs" #-}
lookupUomConversion :: (CommodityType) -> (UnitOfMeasure)
-> (UnitOfMeasure)
-> (UnitOfMeasureConversionType) -> IO ((UnitOfMeasureConversion))
lookupUomConversion :: CommodityType
-> UnitOfMeasure
-> UnitOfMeasure
-> UnitOfMeasureConversionType
-> IO UnitOfMeasureConversion
lookupUomConversion CommodityType
a1 UnitOfMeasure
a2 UnitOfMeasure
a3 UnitOfMeasureConversionType
a4 =
CommodityType
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. CommodityType -> (Ptr CCommodityType -> IO b) -> IO b
withCommodityType CommodityType
a1 ((Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CCommodityType -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CCommodityType
a1' ->
UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a2 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a2' ->
UnitOfMeasure
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall b. UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b
withUnitOfMeasure UnitOfMeasure
a3 ((Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr CUnitOfMeasure -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr CUnitOfMeasure
a3' ->
let {a4' :: CInt
a4' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt)
-> (UnitOfMeasureConversionType -> Int)
-> UnitOfMeasureConversionType
-> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnitOfMeasureConversionType -> Int
forall a. Enum a => a -> Int
fromEnum) UnitOfMeasureConversionType
a4} in
(Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (Ptr (Ptr a) -> IO b) -> IO b
preErrorCheck ((Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion)
-> (Ptr (Ptr ()) -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ())
a5' ->
Ptr CCommodityType
-> Ptr CUnitOfMeasure
-> Ptr CUnitOfMeasure
-> CInt
-> Ptr (Ptr ())
-> IO (Ptr CUnitOfMeasureConversion)
lookupUomConversion'_ Ptr CCommodityType
a1' Ptr CUnitOfMeasure
a2' Ptr CUnitOfMeasure
a3' CInt
a4' Ptr (Ptr ())
a5' IO (Ptr CUnitOfMeasureConversion)
-> (Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ptr CUnitOfMeasureConversion
res ->
Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion
peekUnitOfMeasureConversion Ptr CUnitOfMeasureConversion
res IO UnitOfMeasureConversion
-> (UnitOfMeasureConversion -> IO UnitOfMeasureConversion)
-> IO UnitOfMeasureConversion
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UnitOfMeasureConversion
res' ->
Ptr (Ptr ()) -> IO ()
forall a. Ptr (Ptr a) -> IO ()
errorCheck Ptr (Ptr ())
a5'IO () -> IO UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
UnitOfMeasureConversion -> IO UnitOfMeasureConversion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitOfMeasureConversion
res')
{-# LINE 347 "./QuantLib/Commodity.chs" #-}
addUomConversion :: (UnitOfMeasureConversion) -> IO ()
addUomConversion a1 =
withUnitOfMeasureConversion a1 $ \a1' ->
addUomConversion'_ a1' >>
return ()
{-# LINE 351 "./QuantLib/Commodity.chs" #-}
clearUomConversions :: IO ()
clearUomConversions =
clearUomConversions'_ >>
return ()
{-# LINE 355 "./QuantLib/Commodity.chs" #-}
commoditySettingsCurrency :: IO ((Currency))
commoditySettingsCurrency =
preErrorCheck $ \a1' ->
commoditySettingsCurrency'_ a1' >>= \res ->
peekCurrency res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 358 "./QuantLib/Commodity.chs" #-}
setCommoditySettingsCurrency :: (Currency) -> IO ()
setCommoditySettingsCurrency a1 =
withCurrency a1 $ \a1' ->
setCommoditySettingsCurrency'_ a1' >>
return ()
{-# LINE 361 "./QuantLib/Commodity.chs" #-}
commoditySettingsUnitOfMeasure :: IO ((UnitOfMeasure))
commoditySettingsUnitOfMeasure =
preErrorCheck $ \a1' ->
commoditySettingsUnitOfMeasure'_ a1' >>= \res ->
peekUnitOfMeasure res >>= \res' ->
errorCheck a1'>>
return (res')
{-# LINE 364 "./QuantLib/Commodity.chs" #-}
setCommoditySettingsUnitOfMeasure :: (UnitOfMeasure) -> IO ()
setCommoditySettingsUnitOfMeasure a1 =
withUnitOfMeasure a1 $ \a1' ->
setCommoditySettingsUnitOfMeasure'_ a1' >>
return ()
{-# LINE 367 "./QuantLib/Commodity.chs" #-}
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityType"
commodityType'_ :: ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCommodityType))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlNullCommodityType"
nullCommodityType'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCommodityType))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeCode"
commodityTypeCodeRaw'_ :: ((C2HSImp.Ptr (CCommodityType)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeName"
commodityTypeNameRaw'_ :: ((C2HSImp.Ptr (CCommodityType)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommodityTypeEmpty"
commodityTypeEmpty'_ :: ((C2HSImp.Ptr (CCommodityType)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasure"
unitOfMeasure'_ :: ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureName"
unitOfMeasureNameRaw'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureCode"
unitOfMeasureCodeRaw'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureUnitType"
unitOfMeasureType'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureEmpty"
unitOfMeasureEmpty'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlLotUnitOfMeasure"
lotUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlBarrelUnitOfMeasure"
barrelUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlMTUnitOfMeasure"
mtUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlMBUnitOfMeasure"
mbUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlGallonUnitOfMeasure"
gallonUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlLitreUnitOfMeasure"
litreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlKilolitreUnitOfMeasure"
kilolitreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlTokyoKilolitreUnitOfMeasure"
tokyoKilolitreUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTerm"
paymentTerm'_ :: ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> (C2HSImp.CInt -> ((C2HSImp.Ptr (CCalendar)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CPaymentTerm))))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermName"
paymentTermNameRaw'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermEventType_"
paymentTermEventType'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermOffsetDays"
paymentTermOffsetDays'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermCalendar"
paymentTermCalendar'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCalendar)))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermEmpty"
paymentTermEmpty'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlPaymentTermGetPaymentDate"
paymentTermPaymentDate'_ :: ((C2HSImp.Ptr (CPaymentTerm)) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CInt))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlQuantityRoundedAmount"
quantityRoundedAmount'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> (IO C2HSImp.CDouble)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlQuantityClose"
qlQuantityClose_'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CInt)))))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlQuantityCloseEnough"
qlQuantityCloseEnough_'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CInt)))))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversion"
unitOfMeasureConversion'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionSource"
unitOfMeasureConversionSource'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionTarget"
unitOfMeasureConversionTarget'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure)))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionCommodityType"
unitOfMeasureConversionCommodityType'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCommodityType)))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionType_"
unitOfMeasureConversionType'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO C2HSImp.CInt))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionFactor"
unitOfMeasureConversionFactor'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO C2HSImp.CDouble))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionCode"
unitOfMeasureConversionCodeRaw'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionConvert"
qlUnitOfMeasureConversionConvert_'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CDouble -> ((C2HSImp.Ptr (C2HSImp.Ptr (CCommodityType))) -> ((C2HSImp.Ptr (C2HSImp.Ptr (CUnitOfMeasure))) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO C2HSImp.CDouble))))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionChain"
chainUnitOfMeasureConversion'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionManagerLookup"
lookupUomConversion'_ :: ((C2HSImp.Ptr (CCommodityType)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> ((C2HSImp.Ptr (CUnitOfMeasure)) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasureConversion))))))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionManagerAdd"
addUomConversion'_ :: ((C2HSImp.Ptr (CUnitOfMeasureConversion)) -> (IO ()))
foreign import ccall safe "QuantLib/Commodity.chs.h qlUnitOfMeasureConversionManagerClear"
clearUomConversions'_ :: (IO ())
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsCurrency"
commoditySettingsCurrency'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CCurrency))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsSetCurrency"
setCommoditySettingsCurrency'_ :: ((C2HSImp.Ptr (CCurrency)) -> (IO ()))
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsUnitOfMeasure"
commoditySettingsUnitOfMeasure'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (IO (C2HSImp.Ptr (CUnitOfMeasure))))
foreign import ccall safe "QuantLib/Commodity.chs.h qlCommoditySettingsSetUnitOfMeasure"
setCommoditySettingsUnitOfMeasure'_ :: ((C2HSImp.Ptr (CUnitOfMeasure)) -> (IO ()))