2008-10-01 04:29:58 +04:00
{- |
2011-08-31 21:22:53 +04:00
A simple 'Amount' is some quantity of money , shares , or anything else .
2016-05-08 02:18:04 +03:00
It has a ( possibly null ) 'CommoditySymbol' and a numeric quantity :
2007-03-13 07:11:39 +03:00
2008-10-01 13:33:05 +04:00
@
2014-09-11 00:07:53 +04:00
$ 1
2007-03-13 07:11:39 +03:00
£ - 50
2014-09-11 00:07:53 +04:00
EUR 3.44
2007-03-13 07:11:39 +03:00
GOOG 500
1.5 h
2009-12-13 00:10:39 +03:00
90 apples
2014-09-11 00:07:53 +04:00
0
2008-10-01 13:33:05 +04:00
@
2007-03-13 07:11:39 +03:00
2011-08-31 21:22:53 +04:00
It may also have an assigned 'Price' , representing this amount's per - unit
or total cost in a different commodity . If present , this is rendered like
so :
2007-03-13 07:11:39 +03:00
2008-10-01 13:33:05 +04:00
@
2011-08-31 21:22:53 +04:00
EUR 2 \@ $ 1.50 ( unit price )
EUR 2 \@\@ $ 3 ( total price )
2008-10-01 13:33:05 +04:00
@
2007-03-13 07:11:39 +03:00
2011-08-31 21:22:53 +04:00
A 'MixedAmount' is zero or more simple amounts , so can represent multiple
2011-08-30 17:16:30 +04:00
commodities ; this is the type most often used :
2009-11-25 16:31:08 +03:00
@
2011-08-30 17:16:30 +04:00
0
2009-12-13 00:10:39 +03:00
$ 50 + EUR 3
16 h + $ 13.55 + AAPL 500 + 6 oranges
2008-10-01 13:33:05 +04:00
@
2009-11-25 16:31:08 +03:00
2021-09-19 13:36:07 +03:00
A mixed amount is always \ " normalised \ " , it has no more than one amount
in each commodity and price . When calling 'amounts' it will have no zero
amounts , or just a single zero amount and no other amounts .
2011-08-30 17:16:30 +04:00
2011-08-31 21:22:53 +04:00
Limited arithmetic with simple and mixed amounts is supported , best used
with similar amounts since it mostly ignores assigned prices and commodity
exchange rates .
2009-11-25 16:31:08 +03:00
2007-03-13 07:11:39 +03:00
- }
2020-12-22 14:11:09 +03:00
{- # LANGUAGE OverloadedStrings # -}
{- # LANGUAGE RecordWildCards # -}
lib: textification: commodity symbols
hledger -f data/100x100x10.journal stats
<<ghc: 39288536 bytes, 77 GCs, 196608/269560 avg/max bytes residency (3 samples), 2M in use, 0.000 INIT (0.001 elapsed), 0.016 MUT (0.028 elapsed), 0.009 GC (0.012 elapsed) :ghc>>
<<ghc: 39290808 bytes, 77 GCs, 196608/269560 avg/max bytes residency (3 samples), 2M in use, 0.000 INIT (0.003 elapsed), 0.015 MUT (0.021 elapsed), 0.009 GC (0.011 elapsed) :ghc>>
hledger -f data/1000x100x10.journal stats
<<ghc: 314268960 bytes, 612 GCs, 2143219/6826152 avg/max bytes residency (7 samples), 16M in use, 0.000 INIT (0.009 elapsed), 0.135 MUT (0.151 elapsed), 0.065 GC (0.178 elapsed) :ghc>>
<<ghc: 314254512 bytes, 612 GCs, 2072377/6628024 avg/max bytes residency (7 samples), 16M in use, 0.000 INIT (0.000 elapsed), 0.130 MUT (0.134 elapsed), 0.064 GC (0.075 elapsed) :ghc>>
hledger -f data/10000x100x10.journal stats
<<ghc: 3070016592 bytes, 5965 GCs, 13138220/64266016 avg/max bytes residency (10 samples), 128M in use, 0.000 INIT (0.000 elapsed), 1.272 MUT (1.322 elapsed), 0.527 GC (0.595 elapsed) :ghc>>
<<ghc: 3069989896 bytes, 5973 GCs, 12687877/62848920 avg/max bytes residency (10 samples), 124M in use, 0.000 INIT (0.002 elapsed), 1.295 MUT (1.324 elapsed), 0.511 GC (0.570 elapsed) :ghc>>
hledger -f data/100000x100x10.journal stats
<<ghc: 30753448072 bytes, 59763 GCs, 121502982/673169248 avg/max bytes residency (14 samples), 1640M in use, 0.000 INIT (0.007 elapsed), 12.421 MUT (12.672 elapsed), 6.240 GC (7.812 elapsed) :ghc>>
<<ghc: 30753350528 bytes, 59811 GCs, 117616668/666703600 avg/max bytes residency (14 samples), 1588M in use, 0.001 INIT (0.011 elapsed), 13.209 MUT (13.683 elapsed), 6.137 GC (7.117 elapsed) :ghc>>
2016-05-24 05:13:43 +03:00
2010-12-27 23:26:22 +03:00
module Hledger.Data.Amount (
2021-08-30 11:19:59 +03:00
-- * Commodity
showCommoditySymbol ,
isNonsimpleCommodityChar ,
quoteCommoditySymbolIfNeeded ,
2011-08-31 20:54:10 +04:00
-- * Amount
2012-11-20 01:20:10 +04:00
amount ,
2011-08-31 20:54:10 +04:00
nullamt ,
2012-05-27 22:14:20 +04:00
missingamt ,
2012-11-20 06:22:20 +04:00
num ,
2012-11-20 01:20:10 +04:00
usd ,
eur ,
gbp ,
2019-11-11 23:06:58 +03:00
per ,
2012-11-20 01:20:10 +04:00
hrs ,
at ,
( @@ ) ,
2011-09-02 04:42:41 +04:00
amountWithCommodity ,
2011-08-31 20:54:10 +04:00
-- ** arithmetic
2020-06-01 01:48:08 +03:00
amountCost ,
2020-05-30 04:57:22 +03:00
amountIsZero ,
amountLooksZero ,
2011-08-31 20:54:10 +04:00
divideAmount ,
2018-07-17 01:36:06 +03:00
multiplyAmount ,
2018-11-14 02:37:42 +03:00
amountTotalPriceToUnitPrice ,
2011-08-31 20:54:10 +04:00
-- ** rendering
2020-12-22 15:35:20 +03:00
AmountDisplayOpts ( .. ) ,
noColour ,
noPrice ,
oneLine ,
2021-12-04 15:16:32 +03:00
csvDisplay ,
2012-11-20 01:20:10 +04:00
amountstyle ,
2018-04-20 22:18:28 +03:00
styleAmount ,
2019-10-20 17:08:45 +03:00
styleAmountExceptPrecision ,
2020-11-14 22:08:01 +03:00
amountUnstyled ,
2020-12-22 15:35:20 +03:00
showAmountB ,
2011-08-31 20:54:10 +04:00
showAmount ,
imp: cost: Generate totally balanced conversion postings for amounts with costs.
Introduce --infer-equity option which will generate conversion postings.
--cost will override --infer-equity.
This means there will no longer be unbalanced transactions, but will be
offsetting conversion postings to balance things out. For example.
2000-01-01
a 1 AAA @@ 2 BBB
b -2 BBB
When converting to cost, this is treated the same as before.
When used with --infer-equity, this is now treated as:
2000-01-01
a 1 AAA
equity:conversion:AAA-BBB:AAA -1 AAA
equity:conversion:AAA-BBB:BBB 2 BBB
b -2 BBB
There is a new account type, Conversion/V, which is a subtype of Equity/E.
The first account declared with this type, if any, is used as the base account
for inferred equity postings in conversion transactions, overriding the default
"equity:conversion".
API changes:
Costing has been changed to ConversionOp with three options:
NoConversionOp, ToCost, and InferEquity.
The first correspond to the previous NoCost and Cost options, while the
third corresponds to the --infer-equity flag. This converts transactions with costs
(one or more transaction prices) to transactions with equity:conversion postings.
It is in ConversionOp because converting to cost with -B/--cost and inferring conversion
equity postings with --infer-equity are mutually exclusive.
Correspondingly, the cost_ record of ReportOpts has been changed to
conversionop_.
This also removes show_costs_ option in ReportOpts, as its functionality
has been replaced by the richer cost_ option.
2021-05-04 04:15:55 +03:00
showAmountPrice ,
2017-04-26 04:34:09 +03:00
cshowAmount ,
2014-07-28 17:32:09 +04:00
showAmountWithZeroCommodity ,
2011-08-31 20:54:10 +04:00
showAmountDebug ,
showAmountWithoutPrice ,
2021-02-05 00:57:55 +03:00
amountSetPrecision ,
2012-11-20 01:20:10 +04:00
withPrecision ,
2021-02-05 00:57:55 +03:00
amountSetFullPrecision ,
2018-08-04 18:44:50 +03:00
setAmountInternalPrecision ,
withInternalPrecision ,
setAmountDecimalPoint ,
withDecimalPoint ,
2021-03-22 10:12:33 +03:00
amountStripPrices ,
2012-11-20 01:20:10 +04:00
canonicaliseAmount ,
2011-08-31 20:54:10 +04:00
-- * MixedAmount
nullmixedamt ,
2012-05-27 22:14:20 +04:00
missingmixedamt ,
2021-07-13 10:11:50 +03:00
isMissingMixedAmount ,
2012-11-20 03:17:55 +04:00
mixed ,
2021-01-29 15:34:18 +03:00
mixedAmount ,
maAddAmount ,
maAddAmounts ,
2011-08-31 20:54:10 +04:00
amounts ,
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amountsRaw ,
2021-08-17 23:17:47 +03:00
maCommodities ,
2014-07-02 18:35:06 +04:00
filterMixedAmount ,
2014-07-19 03:45:46 +04:00
filterMixedAmountByCommodity ,
2020-01-21 04:09:07 +03:00
mapMixedAmount ,
2020-06-24 16:38:17 +03:00
unifyMixedAmount ,
2020-01-22 22:57:42 +03:00
mixedAmountStripPrices ,
2011-08-31 20:54:10 +04:00
-- ** arithmetic
2020-06-01 01:48:08 +03:00
mixedAmountCost ,
2021-01-29 15:34:18 +03:00
maNegate ,
maPlus ,
maMinus ,
maSum ,
2011-08-31 20:54:10 +04:00
divideMixedAmount ,
2018-07-17 01:36:06 +03:00
multiplyMixedAmount ,
2014-12-26 22:04:23 +03:00
averageMixedAmounts ,
2016-12-10 18:04:48 +03:00
isNegativeAmount ,
2011-08-31 20:54:10 +04:00
isNegativeMixedAmount ,
2020-05-30 04:57:22 +03:00
mixedAmountIsZero ,
2021-01-29 15:34:18 +03:00
maIsZero ,
maIsNonZero ,
2020-05-30 04:57:22 +03:00
mixedAmountLooksZero ,
2018-11-14 02:37:42 +03:00
mixedAmountTotalPriceToUnitPrice ,
2011-08-31 20:54:10 +04:00
-- ** rendering
2018-04-20 22:18:28 +03:00
styleMixedAmount ,
2020-11-14 22:08:01 +03:00
mixedAmountUnstyled ,
2011-08-31 20:54:10 +04:00
showMixedAmount ,
2015-10-30 04:05:02 +03:00
showMixedAmountOneLine ,
2011-08-31 20:54:10 +04:00
showMixedAmountDebug ,
showMixedAmountWithoutPrice ,
2014-07-28 17:32:09 +04:00
showMixedAmountOneLineWithoutPrice ,
2020-06-26 22:14:49 +03:00
showMixedAmountElided ,
2014-07-28 17:32:09 +04:00
showMixedAmountWithZeroCommodity ,
2020-12-31 14:50:44 +03:00
showMixedAmountB ,
2021-04-12 15:50:56 +03:00
showMixedAmountLinesB ,
2020-12-31 14:50:44 +03:00
wbToText ,
wbUnpack ,
2021-02-05 00:57:55 +03:00
mixedAmountSetPrecision ,
mixedAmountSetFullPrecision ,
2012-11-20 01:20:10 +04:00
canonicaliseMixedAmount ,
2011-08-31 20:54:10 +04:00
-- * misc.
2012-11-12 20:31:43 +04:00
ltraceamount ,
2018-09-06 23:08:26 +03:00
tests_Amount
2011-08-31 20:54:10 +04:00
) where
2021-08-30 11:19:59 +03:00
import Control.Applicative ( liftA2 )
2020-06-24 16:38:17 +03:00
import Control.Monad ( foldM )
2021-08-30 11:19:59 +03:00
import Data.Char ( isDigit )
2020-12-21 15:10:07 +03:00
import Data.Decimal ( DecimalRaw ( .. ) , decimalPlaces , normalizeDecimal , roundTo )
2020-12-22 14:11:09 +03:00
import Data.Default ( Default ( .. ) )
2021-01-16 13:46:39 +03:00
import Data.Foldable ( toList )
2021-03-01 14:35:21 +03:00
import Data.List ( find , foldl' , intercalate , intersperse , mapAccumL , partition )
2020-12-21 15:10:07 +03:00
import Data.List.NonEmpty ( NonEmpty ( .. ) , nonEmpty )
2021-01-16 13:46:39 +03:00
import qualified Data.Map.Strict as M
2021-08-17 23:17:47 +03:00
import qualified Data.Set as S
2021-07-22 21:04:59 +03:00
import Data.Maybe ( fromMaybe , isNothing , isJust )
2021-01-29 15:34:18 +03:00
import Data.Semigroup ( Semigroup ( .. ) )
lib: textification: commodity symbols
hledger -f data/100x100x10.journal stats
<<ghc: 39288536 bytes, 77 GCs, 196608/269560 avg/max bytes residency (3 samples), 2M in use, 0.000 INIT (0.001 elapsed), 0.016 MUT (0.028 elapsed), 0.009 GC (0.012 elapsed) :ghc>>
<<ghc: 39290808 bytes, 77 GCs, 196608/269560 avg/max bytes residency (3 samples), 2M in use, 0.000 INIT (0.003 elapsed), 0.015 MUT (0.021 elapsed), 0.009 GC (0.011 elapsed) :ghc>>
hledger -f data/1000x100x10.journal stats
<<ghc: 314268960 bytes, 612 GCs, 2143219/6826152 avg/max bytes residency (7 samples), 16M in use, 0.000 INIT (0.009 elapsed), 0.135 MUT (0.151 elapsed), 0.065 GC (0.178 elapsed) :ghc>>
<<ghc: 314254512 bytes, 612 GCs, 2072377/6628024 avg/max bytes residency (7 samples), 16M in use, 0.000 INIT (0.000 elapsed), 0.130 MUT (0.134 elapsed), 0.064 GC (0.075 elapsed) :ghc>>
hledger -f data/10000x100x10.journal stats
<<ghc: 3070016592 bytes, 5965 GCs, 13138220/64266016 avg/max bytes residency (10 samples), 128M in use, 0.000 INIT (0.000 elapsed), 1.272 MUT (1.322 elapsed), 0.527 GC (0.595 elapsed) :ghc>>
<<ghc: 3069989896 bytes, 5973 GCs, 12687877/62848920 avg/max bytes residency (10 samples), 124M in use, 0.000 INIT (0.002 elapsed), 1.295 MUT (1.324 elapsed), 0.511 GC (0.570 elapsed) :ghc>>
hledger -f data/100000x100x10.journal stats
<<ghc: 30753448072 bytes, 59763 GCs, 121502982/673169248 avg/max bytes residency (14 samples), 1640M in use, 0.000 INIT (0.007 elapsed), 12.421 MUT (12.672 elapsed), 6.240 GC (7.812 elapsed) :ghc>>
<<ghc: 30753350528 bytes, 59811 GCs, 117616668/666703600 avg/max bytes residency (14 samples), 1588M in use, 0.001 INIT (0.011 elapsed), 13.209 MUT (13.683 elapsed), 6.137 GC (7.117 elapsed) :ghc>>
2016-05-24 05:13:43 +03:00
import qualified Data.Text as T
2020-12-21 15:10:07 +03:00
import qualified Data.Text.Lazy.Builder as TB
2020-08-09 15:31:16 +03:00
import Data.Word ( Word8 )
2020-12-22 15:35:20 +03:00
import Safe ( headDef , lastDef , lastMay )
2021-08-30 10:43:14 +03:00
import System.Console.ANSI ( Color ( .. ) , ColorIntensity ( .. ) )
2021-09-02 12:56:29 +03:00
import Debug.Trace ( trace )
import Test.Tasty ( testGroup )
import Test.Tasty.HUnit ( ( @?= ) , assertBool , testCase )
2010-11-15 02:29:04 +03:00
2010-05-20 03:08:53 +04:00
import Hledger.Data.Types
2021-09-02 12:56:29 +03:00
import Hledger.Utils ( colorB )
import Hledger.Utils.Text ( textQuoteIfNeeded )
2021-11-12 04:49:26 +03:00
import Text.WideString ( WideBuilder ( .. ) , wbFromText , wbToText , wbUnpack )
2008-10-01 04:29:58 +04:00
2018-04-20 22:18:28 +03:00
2021-08-30 11:19:59 +03:00
-- A 'Commodity' is a symbol representing a currency or some other kind of
-- thing we are tracking, and some display preferences that tell how to
-- display 'Amount's of the commodity - is the symbol on the left or right,
-- are thousands separated by comma, significant decimal places and so on.
-- | Show space-containing commodity symbols quoted, as they are in a journal.
showCommoditySymbol :: T . Text -> T . Text
showCommoditySymbol = textQuoteIfNeeded
-- characters that may not be used in a non-quoted commodity symbol
isNonsimpleCommodityChar :: Char -> Bool
isNonsimpleCommodityChar = liftA2 ( || ) isDigit isOther
where
otherChars = " -+.@*; \ t \ n \ " {}= " :: T . Text
isOther c = T . any ( == c ) otherChars
quoteCommoditySymbolIfNeeded :: T . Text -> T . Text
quoteCommoditySymbolIfNeeded s
| T . any isNonsimpleCommodityChar s = " \ " " <> s <> " \ " "
| otherwise = s
2020-12-22 15:35:20 +03:00
-- | Options for the display of Amount and MixedAmount.
2020-12-22 14:11:09 +03:00
data AmountDisplayOpts = AmountDisplayOpts
2020-12-22 15:35:20 +03:00
{ displayPrice :: Bool -- ^ Whether to display the Price of an Amount.
, displayZeroCommodity :: Bool -- ^ If the Amount rounds to 0, whether to display its commodity string.
2021-12-04 15:16:32 +03:00
, displayThousandsSep :: Bool -- ^ Whether to display thousands separators.
2020-12-22 15:35:20 +03:00
, displayColour :: Bool -- ^ Whether to colourise negative Amounts.
, displayOneLine :: Bool -- ^ Whether to display on one line.
, displayMinWidth :: Maybe Int -- ^ Minimum width to pad to
, displayMaxWidth :: Maybe Int -- ^ Maximum width to clip to
2021-07-22 21:04:59 +03:00
-- | Display amounts in this order (without the commodity symbol) and display
-- a 0 in case a corresponding commodity does not exist
, displayOrder :: Maybe [ CommoditySymbol ]
2020-12-22 14:11:09 +03:00
} deriving ( Show )
2020-12-27 02:52:39 +03:00
-- | Display Amount and MixedAmount with no colour.
instance Default AmountDisplayOpts where def = noColour
2020-12-22 14:11:09 +03:00
2020-12-22 15:35:20 +03:00
-- | Display Amount and MixedAmount with no colour.
noColour :: AmountDisplayOpts
2020-12-27 02:52:39 +03:00
noColour = AmountDisplayOpts { displayPrice = True
, displayColour = False
, displayZeroCommodity = False
2021-12-04 15:16:32 +03:00
, displayThousandsSep = True
2020-12-27 02:52:39 +03:00
, displayOneLine = False
2021-07-22 21:04:59 +03:00
, displayMinWidth = Just 0
2020-12-27 02:52:39 +03:00
, displayMaxWidth = Nothing
2021-07-22 21:04:59 +03:00
, displayOrder = Nothing
2020-12-27 02:52:39 +03:00
}
2020-12-22 15:35:20 +03:00
-- | Display Amount and MixedAmount with no prices.
noPrice :: AmountDisplayOpts
noPrice = def { displayPrice = False }
-- | Display Amount and MixedAmount on one line with no prices.
oneLine :: AmountDisplayOpts
oneLine = def { displayOneLine = True , displayPrice = False }
2021-12-04 15:16:32 +03:00
-- | Display Amount and MixedAmount in a form suitable for CSV output.
csvDisplay :: AmountDisplayOpts
csvDisplay = oneLine { displayThousandsSep = False }
2018-04-20 22:18:28 +03:00
-------------------------------------------------------------------------------
-- Amount styles
2019-07-15 13:28:52 +03:00
-- | Default amount style
2020-08-13 14:15:41 +03:00
amountstyle = AmountStyle L False ( Precision 0 ) ( Just '.' ) Nothing
2012-11-20 01:20:10 +04:00
2011-08-31 20:54:10 +04:00
-------------------------------------------------------------------------------
-- Amount
2008-10-18 12:39:08 +04:00
instance Num Amount where
2012-11-20 01:20:10 +04:00
abs a @ Amount { aquantity = q } = a { aquantity = abs q }
signum a @ Amount { aquantity = q } = a { aquantity = signum q }
fromInteger i = nullamt { aquantity = fromInteger i }
2021-11-06 12:32:47 +03:00
negate = transformAmount negate
2012-11-20 01:20:10 +04:00
( + ) = similarAmountsOp ( + )
( - ) = similarAmountsOp ( - )
( * ) = similarAmountsOp ( * )
2008-10-18 12:39:08 +04:00
2011-08-31 20:54:10 +04:00
-- | The empty simple amount.
2012-11-20 02:39:08 +04:00
amount , nullamt :: Amount
2021-07-02 15:54:49 +03:00
amount = Amount { acommodity = " " , aquantity = 0 , aprice = Nothing , astyle = amountstyle }
2012-11-20 01:20:10 +04:00
nullamt = amount
2014-07-28 17:32:09 +04:00
-- | A temporary value for parsed transactions which had no amount specified.
missingamt :: Amount
missingamt = amount { acommodity = " AUTO " }
2015-02-27 16:23:07 +03:00
-- Handy amount constructors for tests.
-- usd/eur/gbp round their argument to a whole number of pennies/cents.
2012-11-20 06:22:20 +04:00
num n = amount { acommodity = " " , aquantity = n }
2020-08-13 14:15:41 +03:00
hrs n = amount { acommodity = " h " , aquantity = n , astyle = amountstyle { asprecision = Precision 2 , ascommodityside = R } }
usd n = amount { acommodity = " $ " , aquantity = roundTo 2 n , astyle = amountstyle { asprecision = Precision 2 } }
eur n = amount { acommodity = " € " , aquantity = roundTo 2 n , astyle = amountstyle { asprecision = Precision 2 } }
gbp n = amount { acommodity = " £ " , aquantity = roundTo 2 n , astyle = amountstyle { asprecision = Precision 2 } }
per n = amount { acommodity = " % " , aquantity = n , astyle = amountstyle { asprecision = Precision 1 , ascommodityside = R , ascommodityspaced = True } }
2019-06-08 00:23:19 +03:00
amt ` at ` priceamt = amt { aprice = Just $ UnitPrice priceamt }
amt @@ priceamt = amt { aprice = Just $ TotalPrice priceamt }
2012-11-20 01:20:10 +04:00
2014-07-28 17:32:09 +04:00
-- | Apply a binary arithmetic operator to two amounts, which should
-- be in the same commodity if non-zero (warning, this is not checked).
-- A zero result keeps the commodity of the second amount.
-- The result's display style is that of the second amount, with
-- precision set to the highest of either amount.
-- Prices are ignored and discarded.
2014-10-18 21:45:17 +04:00
-- Remember: the caller is responsible for ensuring both amounts have the same commodity.
2014-10-18 23:09:43 +04:00
similarAmountsOp :: ( Quantity -> Quantity -> Quantity ) -> Amount -> Amount -> Amount
2021-08-12 06:37:28 +03:00
similarAmountsOp op Amount { acommodity = _ , aquantity = q1 , astyle = AmountStyle { asprecision = p1 } }
Amount { acommodity = c2 , aquantity = q2 , astyle = s2 @ AmountStyle { asprecision = p2 } } =
2014-07-28 17:32:09 +04:00
-- trace ("a1:"++showAmountDebug a1) $ trace ("a2:"++showAmountDebug a2) $ traceWith (("= :"++).showAmountDebug)
amount { acommodity = c2 , aquantity = q1 ` op ` q2 , astyle = s2 { asprecision = max p1 p2 } }
2014-09-11 00:07:53 +04:00
-- c1==c2 || q1==0 || q2==0 =
2012-11-20 03:36:36 +04:00
-- otherwise = error "tried to do simple arithmetic with amounts in different commodities"
2011-04-22 17:44:08 +04:00
2011-08-31 20:54:10 +04:00
-- | Convert an amount to the specified commodity, ignoring and discarding
-- any assigned prices and assuming an exchange rate of 1.
2016-05-08 02:18:04 +03:00
amountWithCommodity :: CommoditySymbol -> Amount -> Amount
2019-06-08 00:23:19 +03:00
amountWithCommodity c a = a { acommodity = c , aprice = Nothing }
2010-02-04 19:40:30 +03:00
2020-06-01 01:48:08 +03:00
-- | Convert a amount to its "cost" or "selling price" in another commodity,
-- using its attached transaction price if it has one. Notes:
2011-08-31 21:44:31 +04:00
--
2020-06-01 01:48:08 +03:00
-- - price amounts must be MixedAmounts with exactly one component Amount
-- (or there will be a runtime error XXX)
2011-08-31 21:44:31 +04:00
--
2021-01-06 12:46:31 +03:00
-- - price amounts should be positive in the Journal
2020-06-01 01:48:08 +03:00
-- (though this is currently not enforced)
amountCost :: Amount -> Amount
amountCost a @ Amount { aquantity = q , aprice = mp } =
2019-06-08 00:23:19 +03:00
case mp of
Nothing -> a
Just ( UnitPrice p @ Amount { aquantity = pq } ) -> p { aquantity = pq * q }
2021-01-06 12:46:31 +03:00
Just ( TotalPrice p @ Amount { aquantity = pq } ) -> p { aquantity = pq }
2008-10-15 05:06:05 +04:00
2018-11-14 02:37:42 +03:00
-- | Replace an amount's TotalPrice, if it has one, with an equivalent UnitPrice.
-- Has no effect on amounts without one.
-- Also increases the unit price's display precision to show one extra decimal place,
2019-07-15 13:28:52 +03:00
-- to help keep transaction amounts balancing.
2018-11-14 02:37:42 +03:00
-- Does Decimal division, might be some rounding/irrational number issues.
amountTotalPriceToUnitPrice :: Amount -> Amount
2019-07-15 13:28:52 +03:00
amountTotalPriceToUnitPrice
2020-08-13 14:15:41 +03:00
a @ Amount { aquantity = q , aprice = Just ( TotalPrice pa @ Amount { aquantity = pq , astyle = ps } ) }
= a { aprice = Just $ UnitPrice pa { aquantity = abs ( pq / q ) , astyle = ps { asprecision = pp } } }
where
-- Increase the precision by 1, capping at the max bound.
pp = case asprecision ps of
NaturalPrecision -> NaturalPrecision
Precision p -> Precision $ if p == maxBound then maxBound else p + 1
2018-11-14 02:37:42 +03:00
amountTotalPriceToUnitPrice a = a
2021-01-06 12:46:31 +03:00
-- | Apply a function to an amount's quantity (and its total price, if it has one).
2021-02-20 02:06:51 +03:00
transformAmount :: ( Quantity -> Quantity ) -> Amount -> Amount
transformAmount f a @ Amount { aquantity = q , aprice = p } = a { aquantity = f q , aprice = f' <$> p }
2021-01-06 12:46:31 +03:00
where
f' ( TotalPrice a @ Amount { aquantity = pq } ) = TotalPrice a { aquantity = f pq }
f' p = p
2018-11-14 04:43:15 +03:00
-- | Divide an amount's quantity (and its total price, if it has one) by a constant.
2021-02-20 02:06:51 +03:00
divideAmount :: Quantity -> Amount -> Amount
divideAmount n = transformAmount ( / n )
2018-11-14 04:43:15 +03:00
-- | Multiply an amount's quantity (and its total price, if it has one) by a constant.
2021-02-20 02:06:51 +03:00
multiplyAmount :: Quantity -> Amount -> Amount
multiplyAmount n = transformAmount ( * n )
2018-11-14 04:43:15 +03:00
2011-08-31 20:54:10 +04:00
-- | Is this amount negative ? The price is ignored.
isNegativeAmount :: Amount -> Bool
2012-11-20 01:20:10 +04:00
isNegativeAmount Amount { aquantity = q } = q < 0
2011-08-31 20:54:10 +04:00
2020-08-21 04:51:50 +03:00
-- | Round an Amount's Quantity to its specified display precision. If that is
2020-08-13 14:15:41 +03:00
-- NaturalPrecision, this does nothing.
amountRoundedQuantity :: Amount -> Quantity
amountRoundedQuantity Amount { aquantity = q , astyle = AmountStyle { asprecision = p } } = case p of
NaturalPrecision -> q
Precision p' -> roundTo p' q
2021-02-20 02:06:51 +03:00
-- | Apply a test to both an Amount and its total price, if it has one.
testAmountAndTotalPrice :: ( Amount -> Bool ) -> Amount -> Bool
testAmountAndTotalPrice f amt = case aprice amt of
Just ( TotalPrice price ) -> f amt && f price
_ -> f amt
2011-08-31 20:54:10 +04:00
2021-02-20 02:06:51 +03:00
-- | Do this Amount and (and its total price, if it has one) appear to be zero when rendered with its
2021-01-16 13:43:24 +03:00
-- display precision ?
2021-02-20 02:06:51 +03:00
amountLooksZero :: Amount -> Bool
2021-03-03 07:57:22 +03:00
amountLooksZero = testAmountAndTotalPrice looksZero
where
looksZero Amount { aquantity = Decimal e q , astyle = AmountStyle { asprecision = p } } = case p of
Precision d -> if e > d then abs q <= 5 * 10 ^ ( e - d - 1 ) else q == 0
NaturalPrecision -> q == 0
2021-01-16 13:43:24 +03:00
2021-02-20 02:06:51 +03:00
-- | Is this Amount (and its total price, if it has one) exactly zero, ignoring its display precision ?
2020-05-30 04:57:22 +03:00
amountIsZero :: Amount -> Bool
2021-03-03 07:57:22 +03:00
amountIsZero = testAmountAndTotalPrice ( \ Amount { aquantity = Decimal _ q } -> q == 0 )
2021-01-16 13:43:24 +03:00
2012-11-20 01:20:10 +04:00
-- | Set an amount's display precision, flipped.
2020-08-13 14:15:41 +03:00
withPrecision :: Amount -> AmountPrecision -> Amount
2021-02-05 00:57:55 +03:00
withPrecision = flip amountSetPrecision
2010-11-13 18:10:06 +03:00
2019-12-01 03:56:45 +03:00
-- | Set an amount's display precision.
2021-02-05 00:57:55 +03:00
amountSetPrecision :: AmountPrecision -> Amount -> Amount
amountSetPrecision p a @ Amount { astyle = s } = a { astyle = s { asprecision = p } }
2019-12-01 03:56:45 +03:00
2020-08-13 14:15:41 +03:00
-- | Increase an amount's display precision, if needed, to enough decimal places
-- to show it exactly (showing all significant decimal digits, excluding trailing
-- zeros).
2021-02-05 00:57:55 +03:00
amountSetFullPrecision :: Amount -> Amount
amountSetFullPrecision a = amountSetPrecision p a
2019-01-17 01:45:50 +03:00
where
2020-01-21 04:09:07 +03:00
p = max displayprecision naturalprecision
2019-01-17 01:45:50 +03:00
displayprecision = asprecision $ astyle a
2020-08-13 14:15:41 +03:00
naturalprecision = Precision . decimalPlaces . normalizeDecimal $ aquantity a
2019-06-15 04:32:45 +03:00
2019-07-15 13:28:52 +03:00
-- | Set an amount's internal precision, ie rounds the Decimal representing
2018-08-04 18:44:50 +03:00
-- the amount's quantity to some number of decimal places.
-- Rounding is done with Data.Decimal's default roundTo function:
-- "If the value ends in 5 then it is rounded to the nearest even value (Banker's Rounding)".
-- Does not change the amount's display precision.
2021-04-13 07:35:39 +03:00
-- Intended mainly for internal use, eg when comparing amounts in tests.
2020-08-09 15:31:16 +03:00
setAmountInternalPrecision :: Word8 -> Amount -> Amount
2019-07-15 13:28:52 +03:00
setAmountInternalPrecision p a @ Amount { aquantity = q , astyle = s } = a {
2020-08-13 14:15:41 +03:00
astyle = s { asprecision = Precision p }
2020-08-09 15:31:16 +03:00
, aquantity = roundTo p q
2018-08-04 18:44:50 +03:00
}
-- | Set an amount's internal precision, flipped.
2021-04-13 07:35:39 +03:00
-- Intended mainly for internal use, eg when comparing amounts in tests.
2020-08-09 15:31:16 +03:00
withInternalPrecision :: Amount -> Word8 -> Amount
2018-08-04 18:44:50 +03:00
withInternalPrecision = flip setAmountInternalPrecision
-- | Set (or clear) an amount's display decimal point.
setAmountDecimalPoint :: Maybe Char -> Amount -> Amount
setAmountDecimalPoint mc a @ Amount { astyle = s } = a { astyle = s { asdecimalpoint = mc } }
-- | Set (or clear) an amount's display decimal point, flipped.
withDecimalPoint :: Amount -> Maybe Char -> Amount
withDecimalPoint = flip setAmountDecimalPoint
2021-03-22 10:12:33 +03:00
-- | Strip all prices from an Amount
amountStripPrices :: Amount -> Amount
amountStripPrices a = a { aprice = Nothing }
2021-01-06 12:46:31 +03:00
showAmountPrice :: Amount -> WideBuilder
showAmountPrice amt = case aprice amt of
Nothing -> mempty
Just ( UnitPrice pa ) -> WideBuilder ( TB . fromString " @ " ) 3 <> showAmountB noColour pa
Just ( TotalPrice pa ) -> WideBuilder ( TB . fromString " @@ " ) 4 <> showAmountB noColour ( sign pa )
where sign = if aquantity amt < 0 then negate else id
2011-04-22 17:40:55 +04:00
2019-06-08 00:23:19 +03:00
showAmountPriceDebug :: Maybe AmountPrice -> String
showAmountPriceDebug Nothing = " "
showAmountPriceDebug ( Just ( UnitPrice pa ) ) = " @ " ++ showAmountDebug pa
showAmountPriceDebug ( Just ( TotalPrice pa ) ) = " @@ " ++ showAmountDebug pa
2011-04-22 17:40:55 +04:00
2020-06-01 01:48:08 +03:00
-- | Given a map of standard commodity display styles, apply the
-- appropriate one to this amount. If there's no standard style for
-- this amount's commodity, return the amount unchanged.
2021-09-14 22:18:43 +03:00
-- Also apply the style to the price (except for precision)
2018-04-20 22:18:28 +03:00
styleAmount :: M . Map CommoditySymbol AmountStyle -> Amount -> Amount
2021-09-14 22:18:43 +03:00
styleAmount styles a = styledAmount { aprice = stylePrice styles ( aprice styledAmount ) }
where
styledAmount = case M . lookup ( acommodity a ) styles of
Just s -> a { astyle = s }
Nothing -> a
stylePrice :: M . Map CommoditySymbol AmountStyle -> Maybe AmountPrice -> Maybe AmountPrice
stylePrice styles ( Just ( UnitPrice a ) ) = Just ( UnitPrice $ styleAmountExceptPrecision styles a )
stylePrice styles ( Just ( TotalPrice a ) ) = Just ( TotalPrice $ styleAmountExceptPrecision styles a )
stylePrice _ _ = Nothing
2018-04-20 22:18:28 +03:00
2019-10-20 17:08:45 +03:00
-- | Like styleAmount, but keep the number of decimal places unchanged.
styleAmountExceptPrecision :: M . Map CommoditySymbol AmountStyle -> Amount -> Amount
styleAmountExceptPrecision styles a @ Amount { astyle = AmountStyle { asprecision = origp } } =
case M . lookup ( acommodity a ) styles of
Just s -> a { astyle = s { asprecision = origp } }
Nothing -> a
2020-11-14 22:08:01 +03:00
-- | Reset this amount's display style to the default.
amountUnstyled :: Amount -> Amount
amountUnstyled a = a { astyle = amountstyle }
2014-07-28 17:32:09 +04:00
-- | Get the string representation of an amount, based on its
-- commodity's display settings. String representations equivalent to
-- zero are converted to just \"0\". The special "missing" amount is
-- displayed as the empty string.
2020-12-31 14:50:44 +03:00
--
-- > showAmount = wbUnpack . showAmountB noColour
2011-04-22 17:40:55 +04:00
showAmount :: Amount -> String
2020-12-22 15:35:20 +03:00
showAmount = wbUnpack . showAmountB noColour
2020-12-22 14:11:09 +03:00
2020-12-31 14:50:44 +03:00
-- | General function to generate a WideBuilder for an Amount, according the
-- supplied AmountDisplayOpts. The special "missing" amount is displayed as
-- the empty string. This is the main function to use for showing
-- Amounts, constructing a builder; it can then be converted to a Text with
-- wbToText, or to a String with wbUnpack.
2020-12-22 14:11:09 +03:00
showAmountB :: AmountDisplayOpts -> Amount -> WideBuilder
showAmountB _ Amount { acommodity = " AUTO " } = mempty
showAmountB opts a @ Amount { astyle = style } =
color $ case ascommodityside style of
2021-11-12 04:49:26 +03:00
L -> showC ( wbFromText c ) space <> quantity' <> price
R -> quantity' <> showC space ( wbFromText c ) <> price
2020-12-22 14:11:09 +03:00
where
2021-12-04 15:16:32 +03:00
quantity = showamountquantity $ if displayThousandsSep opts then a else a { astyle = ( astyle a ) { asdigitgroups = Nothing } }
2020-12-22 14:11:09 +03:00
( quantity' , c ) | amountLooksZero a && not ( displayZeroCommodity opts ) = ( WideBuilder ( TB . singleton '0' ) 1 , " " )
2020-12-22 15:35:20 +03:00
| otherwise = ( quantity , quoteCommoditySymbolIfNeeded $ acommodity a )
2020-12-22 14:11:09 +03:00
space = if not ( T . null c ) && ascommodityspaced style then WideBuilder ( TB . singleton ' ' ) 1 else mempty
2021-07-22 21:04:59 +03:00
showC l r = if isJust ( displayOrder opts ) then mempty else l <> r
2021-01-06 12:46:31 +03:00
price = if displayPrice opts then showAmountPrice a else mempty
2020-12-22 14:11:09 +03:00
color = if displayColour opts && isNegativeAmount a then colorB Dull Red else id
2014-07-28 17:32:09 +04:00
2019-07-15 13:28:52 +03:00
-- | Colour version. For a negative amount, adds ANSI codes to change the colour,
2017-04-26 04:34:09 +03:00
-- currently to hard-coded red.
2020-12-31 14:50:44 +03:00
--
-- > cshowAmount = wbUnpack . showAmountB def{displayColour=True}
2017-04-26 04:34:09 +03:00
cshowAmount :: Amount -> String
2020-12-31 14:50:44 +03:00
cshowAmount = wbUnpack . showAmountB def { displayColour = True }
2020-09-14 09:22:07 +03:00
-- | Get the string representation of an amount, without any \@ price.
2020-12-31 14:50:44 +03:00
--
-- > showAmountWithoutPrice = wbUnpack . showAmountB noPrice
2020-09-14 09:22:07 +03:00
showAmountWithoutPrice :: Amount -> String
2020-12-27 02:52:39 +03:00
showAmountWithoutPrice = wbUnpack . showAmountB noPrice
2017-04-26 04:34:09 +03:00
2014-07-28 17:32:09 +04:00
-- | Like showAmount, but show a zero amount's commodity if it has one.
2020-12-31 14:50:44 +03:00
--
-- > showAmountWithZeroCommodity = wbUnpack . showAmountB noColour{displayZeryCommodity=True}
2014-07-28 17:32:09 +04:00
showAmountWithZeroCommodity :: Amount -> String
2020-12-22 15:35:20 +03:00
showAmountWithZeroCommodity = wbUnpack . showAmountB noColour { displayZeroCommodity = True }
2014-07-28 17:32:09 +04:00
2020-09-14 09:22:07 +03:00
-- | Get a string representation of an amount for debugging,
-- appropriate to the current debug level. 9 shows maximum detail.
showAmountDebug :: Amount -> String
showAmountDebug Amount { acommodity = " AUTO " } = " (missing) "
2021-09-02 12:56:29 +03:00
showAmountDebug Amount { .. } =
" Amount {acommodity= " ++ show acommodity ++ " , aquantity= " ++ show aquantity
++ " , aprice= " ++ showAmountPriceDebug aprice ++ " , astyle= " ++ show astyle ++ " } "
2020-09-14 09:22:07 +03:00
2020-12-21 15:10:07 +03:00
-- | Get a Text Builder for the string representation of the number part of of an amount,
-- using the display settings from its commodity. Also returns the width of the
-- number.
showamountquantity :: Amount -> WideBuilder
2020-08-13 14:15:41 +03:00
showamountquantity amt @ Amount { astyle = AmountStyle { asdecimalpoint = mdec , asdigitgroups = mgrps } } =
2020-12-21 15:10:07 +03:00
signB <> intB <> fracB
where
Decimal e n = amountRoundedQuantity amt
2020-12-22 15:35:20 +03:00
strN = T . pack . show $ abs n
len = T . length strN
2020-12-21 15:10:07 +03:00
intLen = max 1 $ len - fromIntegral e
dec = fromMaybe '.' mdec
2020-12-22 15:35:20 +03:00
padded = T . replicate ( fromIntegral e + 1 - len ) " 0 " <> strN
( intPart , fracPart ) = T . splitAt intLen padded
2020-12-21 15:10:07 +03:00
intB = applyDigitGroupStyle mgrps intLen $ if e == 0 then strN else intPart
signB = if n < 0 then WideBuilder ( TB . singleton '-' ) 1 else mempty
2020-12-22 15:35:20 +03:00
fracB = if e > 0 then WideBuilder ( TB . singleton dec <> TB . fromText fracPart ) ( fromIntegral e + 1 ) else mempty
2020-12-21 15:10:07 +03:00
-- | Split a string representation into chunks according to DigitGroupStyle,
-- returning a Text builder and the number of separators used.
2020-12-22 15:35:20 +03:00
applyDigitGroupStyle :: Maybe DigitGroupStyle -> Int -> T . Text -> WideBuilder
applyDigitGroupStyle Nothing l s = WideBuilder ( TB . fromText s ) l
applyDigitGroupStyle ( Just ( DigitGroups _ [] ) ) l s = WideBuilder ( TB . fromText s ) l
2020-12-21 15:10:07 +03:00
applyDigitGroupStyle ( Just ( DigitGroups c ( g : gs ) ) ) l s = addseps ( g :| gs ) ( toInteger l ) s
look harder for decimal point & digit groups (fixes #196)
Amount display styles have been reworked a bit; they are now calculated
after journal parsing, not during it. This allows the fix for #196:
we now search through the amounts until a decimal point is detected,
instead of just looking at the first one; likewise for digit groups.
Digit groups are now implemented with a better type.
Digit group size detection has been improved a little:
1000,000 now gives group sizes [3,4,4,...], not [3,3,...], and
10,000 gives groups sizes [3,3,...] not [3,2,2,..].
(To get [3,2,2,...] you'd use eg 00,00,000.)
There are still some old (or new ?) issues; I don't think we handle
inconsistent decimal points & digit groups too well. But for now all
tests pass.
2014-07-03 10:26:16 +04:00
where
2020-12-21 15:10:07 +03:00
addseps ( g :| gs ) l s
2020-12-22 15:35:20 +03:00
| l' > 0 = addseps gs' l' rest <> WideBuilder ( TB . singleton c <> TB . fromText part ) ( fromIntegral g + 1 )
| otherwise = WideBuilder ( TB . fromText s ) ( fromInteger l )
2020-12-21 15:10:07 +03:00
where
2020-12-22 15:35:20 +03:00
( rest , part ) = T . splitAt ( fromInteger l' ) s
2020-12-21 15:10:07 +03:00
gs' = fromMaybe ( g :| [] ) $ nonEmpty gs
l' = l - toInteger g
2011-01-19 15:32:18 +03:00
2012-11-20 01:20:10 +04:00
-- like journalCanonicaliseAmounts
-- | Canonicalise an amount's display style using the provided commodity style map.
2016-05-08 02:18:04 +03:00
canonicaliseAmount :: M . Map CommoditySymbol AmountStyle -> Amount -> Amount
2012-11-20 01:20:10 +04:00
canonicaliseAmount styles a @ Amount { acommodity = c , astyle = s } = a { astyle = s' }
2021-01-16 13:43:24 +03:00
where s' = M . findWithDefault s c styles
2011-08-31 20:54:10 +04:00
-------------------------------------------------------------------------------
-- MixedAmount
2021-01-29 15:34:18 +03:00
instance Semigroup MixedAmount where
( <> ) = maPlus
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
sconcat = maSum
stimes n = multiplyMixedAmount ( fromIntegral n )
2021-01-29 15:34:18 +03:00
instance Monoid MixedAmount where
mempty = nullmixedamt
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mconcat = maSum
2021-01-29 15:34:18 +03:00
2011-08-31 20:54:10 +04:00
instance Num MixedAmount where
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
fromInteger = mixedAmount . fromInteger
negate = maNegate
( + ) = maPlus
2021-09-02 12:56:29 +03:00
( * ) = error " error, mixed amounts do not support multiplication " -- PARTIAL:
abs = error " error, mixed amounts do not support abs "
signum = error " error, mixed amounts do not support signum "
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- | Calculate the key used to store an Amount within a MixedAmount.
amountKey :: Amount -> MixedAmountKey
amountKey amt @ Amount { acommodity = c } = case aprice amt of
Nothing -> MixedAmountKeyNoPrice c
Just ( TotalPrice p ) -> MixedAmountKeyTotalPrice c ( acommodity p )
Just ( UnitPrice p ) -> MixedAmountKeyUnitPrice c ( acommodity p ) ( aquantity p )
2011-08-31 20:54:10 +04:00
-- | The empty mixed amount.
nullmixedamt :: MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
nullmixedamt = Mixed mempty
2011-08-31 20:54:10 +04:00
-- | A temporary value for parsed transactions which had no amount specified.
2012-05-27 22:14:20 +04:00
missingmixedamt :: MixedAmount
2021-01-31 07:23:46 +03:00
missingmixedamt = mixedAmount missingamt
2012-05-27 22:14:20 +04:00
2021-07-13 10:11:50 +03:00
-- | Whether a MixedAmount has a missing amount
isMissingMixedAmount :: MixedAmount -> Bool
isMissingMixedAmount ( Mixed ma ) = amountKey missingamt ` M . member ` ma
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- | Convert amounts in various commodities into a mixed amount.
mixed :: Foldable t => t Amount -> MixedAmount
mixed = maAddAmounts nullmixedamt
2012-11-12 20:31:43 +04:00
2021-01-29 15:34:18 +03:00
-- | Create a MixedAmount from a single Amount.
mixedAmount :: Amount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mixedAmount a = Mixed $ M . singleton ( amountKey a ) a
2021-01-29 15:34:18 +03:00
-- | Add an Amount to a MixedAmount, normalising the result.
maAddAmount :: MixedAmount -> Amount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
maAddAmount ( Mixed ma ) a = Mixed $ M . insertWith sumSimilarAmountsUsingFirstPrice ( amountKey a ) a ma
2021-01-29 15:34:18 +03:00
-- | Add a collection of Amounts to a MixedAmount, normalising the result.
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
maAddAmounts :: Foldable t => MixedAmount -> t Amount -> MixedAmount
maAddAmounts = foldl' maAddAmount
2021-01-29 15:34:18 +03:00
-- | Negate mixed amount's quantities (and total prices, if any).
maNegate :: MixedAmount -> MixedAmount
maNegate = transformMixedAmount negate
-- | Sum two MixedAmount.
maPlus :: MixedAmount -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
maPlus ( Mixed as ) ( Mixed bs ) = Mixed $ M . unionWith sumSimilarAmountsUsingFirstPrice as bs
2021-01-29 15:34:18 +03:00
-- | Subtract a MixedAmount from another.
maMinus :: MixedAmount -> MixedAmount -> MixedAmount
maMinus a = maPlus a . maNegate
-- | Sum a collection of MixedAmounts.
maSum :: Foldable t => t MixedAmount -> MixedAmount
maSum = foldl' maPlus nullmixedamt
-- | Divide a mixed amount's quantities (and total prices, if any) by a constant.
divideMixedAmount :: Quantity -> MixedAmount -> MixedAmount
divideMixedAmount n = transformMixedAmount ( / n )
-- | Multiply a mixed amount's quantities (and total prices, if any) by a constant.
multiplyMixedAmount :: Quantity -> MixedAmount -> MixedAmount
multiplyMixedAmount n = transformMixedAmount ( * n )
-- | Apply a function to a mixed amount's quantities (and its total prices, if it has any).
transformMixedAmount :: ( Quantity -> Quantity ) -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
transformMixedAmount f = mapMixedAmountUnsafe ( transformAmount f )
2021-01-29 15:34:18 +03:00
-- | Calculate the average of some mixed amounts.
averageMixedAmounts :: [ MixedAmount ] -> MixedAmount
averageMixedAmounts as = fromIntegral ( length as ) ` divideMixedAmount ` maSum as
-- | Is this mixed amount negative, if we can tell that unambiguously?
-- Ie when normalised, are all individual commodity amounts negative ?
isNegativeMixedAmount :: MixedAmount -> Maybe Bool
isNegativeMixedAmount m =
2021-09-19 13:36:07 +03:00
case amounts $ mixedAmountStripPrices m of
2021-01-29 15:34:18 +03:00
[] -> Just False
[ a ] -> Just $ isNegativeAmount a
as | all isNegativeAmount as -> Just True
as | not ( any isNegativeAmount as ) -> Just False
_ -> Nothing -- multiple amounts with different signs
-- | Does this mixed amount appear to be zero when rendered with its display precision?
-- i.e. does it have zero quantity with no price, zero quantity with a total price (which is also zero),
-- and zero quantity for each unit price?
mixedAmountLooksZero :: MixedAmount -> Bool
2021-09-17 15:03:09 +03:00
mixedAmountLooksZero ( Mixed ma ) = all amountLooksZero ma
2021-01-29 15:34:18 +03:00
-- | Is this mixed amount exactly zero, ignoring its display precision?
-- i.e. does it have zero quantity with no price, zero quantity with a total price (which is also zero),
-- and zero quantity for each unit price?
mixedAmountIsZero :: MixedAmount -> Bool
2021-09-17 15:03:09 +03:00
mixedAmountIsZero ( Mixed ma ) = all amountIsZero ma
2021-01-29 15:34:18 +03:00
-- | Is this mixed amount exactly zero, ignoring its display precision?
--
-- A convenient alias for mixedAmountIsZero.
maIsZero :: MixedAmount -> Bool
maIsZero = mixedAmountIsZero
-- | Is this mixed amount non-zero, ignoring its display precision?
--
-- A convenient alias for not . mixedAmountIsZero.
maIsNonZero :: MixedAmount -> Bool
maIsNonZero = not . mixedAmountIsZero
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- | Get a mixed amount's component amounts.
2014-07-28 17:32:09 +04:00
--
-- * amounts in the same commodity are combined unless they have different prices or total prices
--
balance, etc: fix amount style loss (fixes #230, #276)
hledger-lib-0.24's "track the commodity of zero amounts when
possible (useful eg for hledger-web's multi-commodity charts)" preserved
the commodity when normalising a zero mixed amount, but not the amount
style. This showed up as occasionally incorrect amount style (commodity
symbol placement, decimal point character, etc.) in balance reports with
certain journals, like this:
$ hledger bal
€3000.00 a <------ not using the canonical € style
4000,58€ 1
-1000,58€ D
-3000,00€ e
--------------------
0
I thought this would require a big rewrite of amount arithmetic, but it
seems that just being a little more careful is enough. When normalising
a mixed amount containing multiple zeros in the same commodity, we now
preserve the last zero with its amount style, instead of replacing them
all with a new one.
2015-09-03 02:09:49 +03:00
-- * multiple zero amounts, all with the same non-null commodity, are replaced by just the last of them, preserving the commodity and amount style (all but the last zero amount are discarded)
2014-07-28 17:32:09 +04:00
--
balance, etc: fix amount style loss (fixes #230, #276)
hledger-lib-0.24's "track the commodity of zero amounts when
possible (useful eg for hledger-web's multi-commodity charts)" preserved
the commodity when normalising a zero mixed amount, but not the amount
style. This showed up as occasionally incorrect amount style (commodity
symbol placement, decimal point character, etc.) in balance reports with
certain journals, like this:
$ hledger bal
€3000.00 a <------ not using the canonical € style
4000,58€ 1
-1000,58€ D
-3000,00€ e
--------------------
0
I thought this would require a big rewrite of amount arithmetic, but it
seems that just being a little more careful is enough. When normalising
a mixed amount containing multiple zeros in the same commodity, we now
preserve the last zero with its amount style, instead of replacing them
all with a new one.
2015-09-03 02:09:49 +03:00
-- * multiple zero amounts with multiple commodities, or no commodities, are replaced by one commodity-less zero amount
--
-- * an empty amount list is replaced by one commodity-less zero amount
2014-07-28 17:32:09 +04:00
--
-- * the special "missing" mixed amount remains unchanged
--
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts :: MixedAmount -> [ Amount ]
amounts ( Mixed ma )
2021-07-13 10:11:50 +03:00
| isMissingMixedAmount ( Mixed ma ) = [ missingamt ] -- missingamt should always be alone, but detect it even if not
| M . null nonzeros = [ newzero ]
| otherwise = toList nonzeros
2014-07-28 17:32:09 +04:00
where
2021-03-01 14:35:21 +03:00
newzero = fromMaybe nullamt $ find ( not . T . null . acommodity ) zeros
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
( zeros , nonzeros ) = M . partition amountIsZero ma
2014-07-28 17:32:09 +04:00
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- | Get a mixed amount's component amounts without normalising zero and missing
-- amounts. This is used for JSON serialisation, so the order is important. In
-- particular, we want the Amounts given in the order of the MixedAmountKeys,
-- i.e. lexicographically first by commodity, then by price commodity, then by
-- unit price from most negative to most positive.
amountsRaw :: MixedAmount -> [ Amount ]
amountsRaw ( Mixed ma ) = toList ma
2021-08-20 06:43:45 +03:00
-- | Get this mixed amount's commodities as a set.
-- Returns an empty set if there are no amounts.
2021-08-17 23:17:47 +03:00
maCommodities :: MixedAmount -> S . Set CommoditySymbol
maCommodities = S . fromList . fmap acommodity . amounts'
where amounts' ma @ ( Mixed m ) = if M . null m then [] else amounts ma
2020-06-24 16:38:17 +03:00
-- | Unify a MixedAmount to a single commodity value if possible.
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- This consolidates amounts of the same commodity and discards zero
-- amounts; but this one insists on simplifying to a single commodity,
-- and will return Nothing if this is not possible.
2020-06-24 16:38:17 +03:00
unifyMixedAmount :: MixedAmount -> Maybe Amount
unifyMixedAmount = foldM combine 0 . amounts
where
combine amount result
| amountIsZero amount = Just result
| amountIsZero result = Just amount
| acommodity amount == acommodity result = Just $ amount + result
| otherwise = Nothing
2014-07-28 17:32:09 +04:00
-- | Sum same-commodity amounts in a lossy way, applying the first
-- price to the result and discarding any other prices. Only used as a
-- rendering helper.
2021-01-16 13:46:39 +03:00
sumSimilarAmountsUsingFirstPrice :: Amount -> Amount -> Amount
sumSimilarAmountsUsingFirstPrice a b = ( a + b ) { aprice = p }
where
p = case ( aprice a , aprice b ) of
( Just ( TotalPrice ap ) , Just ( TotalPrice bp ) )
-> Just . TotalPrice $ ap { aquantity = aquantity ap + aquantity bp }
_ -> aprice a
2014-07-28 17:32:09 +04:00
2016-08-03 19:29:22 +03:00
-- -- | Sum same-commodity amounts. If there were different prices, set
-- -- the price to a special marker indicating "various". Only used as a
-- -- rendering helper.
2014-07-28 17:32:09 +04:00
-- sumSimilarAmountsNotingPriceDifference :: [Amount] -> Amount
-- sumSimilarAmountsNotingPriceDifference [] = nullamt
-- sumSimilarAmountsNotingPriceDifference as = undefined
2010-07-28 03:20:20 +04:00
2014-07-02 18:35:06 +04:00
-- | Filter a mixed amount's component amounts by a predicate.
filterMixedAmount :: ( Amount -> Bool ) -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
filterMixedAmount p ( Mixed ma ) = Mixed $ M . filter p ma
2014-07-02 18:35:06 +04:00
2014-07-19 03:45:46 +04:00
-- | Return an unnormalised MixedAmount containing exactly one Amount
-- with the specified commodity and the quantity of that commodity
-- found in the original. NB if Amount's quantity is zero it will be
-- discarded next time the MixedAmount gets normalised.
2016-05-08 02:18:04 +03:00
filterMixedAmountByCommodity :: CommoditySymbol -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
filterMixedAmountByCommodity c ( Mixed ma )
| M . null ma' = mixedAmount nullamt { acommodity = c }
| otherwise = Mixed ma'
where ma' = M . filter ( ( c == ) . acommodity ) ma
2014-07-19 03:45:46 +04:00
2018-11-14 04:25:32 +03:00
-- | Apply a transform to a mixed amount's component 'Amount's.
mapMixedAmount :: ( Amount -> Amount ) -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mapMixedAmount f ( Mixed ma ) = mixed . map f $ toList ma
-- | Apply a transform to a mixed amount's component 'Amount's, which does not
-- affect the key of the amount (i.e. doesn't change the commodity, price
-- commodity, or unit price amount). This condition is not checked.
mapMixedAmountUnsafe :: ( Amount -> Amount ) -> MixedAmount -> MixedAmount
mapMixedAmountUnsafe f ( Mixed ma ) = Mixed $ M . map f ma -- Use M.map instead of fmap to maintain strictness
2018-11-14 04:25:32 +03:00
2020-06-01 01:48:08 +03:00
-- | Convert all component amounts to cost/selling price where
-- possible (see amountCost).
mixedAmountCost :: MixedAmount -> MixedAmount
2021-09-17 15:03:09 +03:00
mixedAmountCost ( Mixed ma ) =
foldl' ( \ m a -> maAddAmount m ( amountCost a ) ) ( Mixed noPrices ) withPrices
where ( noPrices , withPrices ) = M . partition ( isNothing . aprice ) ma
2019-05-23 22:15:54 +03:00
2011-08-31 20:54:10 +04:00
-- -- | MixedAmount derived Eq instance in Types.hs doesn't know that we
-- -- want $0 = EUR0 = 0. Yet we don't want to drag all this code over there.
-- -- For now, use this when cross-commodity zero equality is important.
2010-12-27 23:26:22 +03:00
-- mixedAmountEquals :: MixedAmount -> MixedAmount -> Bool
2020-05-30 04:57:22 +03:00
-- mixedAmountEquals a b = amounts a' == amounts b' || (mixedAmountLooksZero a' && mixedAmountLooksZero b')
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- where a' = mixedAmountStripPrices a
-- b' = mixedAmountStripPrices b
2009-01-17 21:07:20 +03:00
2020-06-01 01:48:08 +03:00
-- | Given a map of standard commodity display styles, apply the
-- appropriate one to each individual amount.
2018-04-20 22:18:28 +03:00
styleMixedAmount :: M . Map CommoditySymbol AmountStyle -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
styleMixedAmount styles = mapMixedAmountUnsafe ( styleAmount styles )
2018-04-20 22:18:28 +03:00
2020-11-14 22:08:01 +03:00
-- | Reset each individual amount's display style to the default.
mixedAmountUnstyled :: MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mixedAmountUnstyled = mapMixedAmountUnsafe amountUnstyled
2020-11-14 22:08:01 +03:00
2014-07-28 17:32:09 +04:00
-- | Get the string representation of a mixed amount, after
-- normalising it to one amount per commodity. Assumes amounts have
-- no or similar prices, otherwise this can show misleading prices.
2020-12-31 14:50:44 +03:00
--
-- > showMixedAmount = wbUnpack . showMixedAmountB noColour
2008-10-19 00:27:25 +04:00
showMixedAmount :: MixedAmount -> String
2020-12-31 14:50:44 +03:00
showMixedAmount = wbUnpack . showMixedAmountB noColour
2014-07-28 17:32:09 +04:00
2015-10-30 04:05:02 +03:00
-- | Get the one-line string representation of a mixed amount.
2020-12-31 14:50:44 +03:00
--
-- > showMixedAmountOneLine = wbUnpack . showMixedAmountB oneLine
2015-10-30 04:05:02 +03:00
showMixedAmountOneLine :: MixedAmount -> String
2020-12-31 14:50:44 +03:00
showMixedAmountOneLine = wbUnpack . showMixedAmountB oneLine
2015-10-30 04:05:02 +03:00
2020-09-14 09:22:07 +03:00
-- | Like showMixedAmount, but zero amounts are shown with their
-- commodity if they have one.
2020-12-31 14:50:44 +03:00
--
-- > showMixedAmountWithZeroCommodity = wbUnpack . showMixedAmountB noColour{displayZeroCommodity=True}
2020-09-14 09:22:07 +03:00
showMixedAmountWithZeroCommodity :: MixedAmount -> String
2020-12-31 14:50:44 +03:00
showMixedAmountWithZeroCommodity = wbUnpack . showMixedAmountB noColour { displayZeroCommodity = True }
2018-02-16 13:26:39 +03:00
-- | Get the string representation of a mixed amount, without showing any transaction prices.
2020-06-26 22:59:47 +03:00
-- With a True argument, adds ANSI codes to show negative amounts in red.
2020-12-31 14:50:44 +03:00
--
-- > showMixedAmountWithoutPrice c = wbUnpack . showMixedAmountB noPrice{displayColour=c}
2020-06-26 22:59:47 +03:00
showMixedAmountWithoutPrice :: Bool -> MixedAmount -> String
2020-12-31 14:50:44 +03:00
showMixedAmountWithoutPrice c = wbUnpack . showMixedAmountB noPrice { displayColour = c }
2018-02-16 04:28:23 +03:00
2014-07-03 18:45:55 +04:00
-- | Get the one-line string representation of a mixed amount, but without
-- any \@ prices.
2020-06-26 22:59:47 +03:00
-- With a True argument, adds ANSI codes to show negative amounts in red.
2020-12-31 14:50:44 +03:00
--
-- > showMixedAmountOneLineWithoutPrice c = wbUnpack . showMixedAmountB oneLine{displayColour=c}
2020-06-26 22:59:47 +03:00
showMixedAmountOneLineWithoutPrice :: Bool -> MixedAmount -> String
2020-12-31 14:50:44 +03:00
showMixedAmountOneLineWithoutPrice c = wbUnpack . showMixedAmountB oneLine { displayColour = c }
2017-04-26 04:34:09 +03:00
2020-09-15 09:53:14 +03:00
-- | Like showMixedAmountOneLineWithoutPrice, but show at most the given width,
2020-09-14 09:22:07 +03:00
-- with an elision indicator if there are more.
2020-06-26 22:59:47 +03:00
-- With a True argument, adds ANSI codes to show negative amounts in red.
2020-12-31 14:50:44 +03:00
--
-- > showMixedAmountElided w c = wbUnpack . showMixedAmountB oneLine{displayColour=c, displayMaxWidth=Just w}
2020-09-15 09:53:14 +03:00
showMixedAmountElided :: Int -> Bool -> MixedAmount -> String
2020-12-31 14:50:44 +03:00
showMixedAmountElided w c = wbUnpack . showMixedAmountB oneLine { displayColour = c , displayMaxWidth = Just w }
2020-09-14 09:22:07 +03:00
-- | Get an unambiguous string representation of a mixed amount for debugging.
showMixedAmountDebug :: MixedAmount -> String
showMixedAmountDebug m | m == missingmixedamt = " (missing) "
2021-09-02 12:56:29 +03:00
| otherwise = " Mixed [ " ++ as ++ " ] "
2020-09-14 09:22:07 +03:00
where as = intercalate " \ n " $ map showAmountDebug $ amounts m
2021-03-08 08:01:54 +03:00
-- | General function to generate a WideBuilder for a MixedAmount, according to the
2020-12-31 14:50:44 +03:00
-- supplied AmountDisplayOpts. This is the main function to use for showing
-- MixedAmounts, constructing a builder; it can then be converted to a Text with
-- wbToText, or to a String with wbUnpack.
--
-- If a maximum width is given then:
2020-12-22 15:35:20 +03:00
-- - If displayed on one line, it will display as many Amounts as can
2021-04-12 15:50:56 +03:00
-- fit in the given width, and further Amounts will be elided. There
-- will always be at least one amount displayed, even if this will
-- exceed the requested maximum width.
2020-12-22 15:35:20 +03:00
-- - If displayed on multiple lines, any Amounts longer than the
-- maximum width will be elided.
2020-12-31 14:50:44 +03:00
showMixedAmountB :: AmountDisplayOpts -> MixedAmount -> WideBuilder
2021-04-12 15:50:56 +03:00
showMixedAmountB opts ma
| displayOneLine opts = showMixedAmountOneLineB opts ma
| otherwise = WideBuilder ( wbBuilder . mconcat $ intersperse sep lines ) width
where
lines = showMixedAmountLinesB opts ma
width = headDef 0 $ map wbWidth lines
sep = WideBuilder ( TB . singleton '\ n' ) 0
-- | Helper for showMixedAmountB to show a list of Amounts on multiple lines. This returns
-- the list of WideBuilders: one for each Amount, and padded/elided to the appropriate
-- width. This does not honour displayOneLine: all amounts will be displayed as if
-- displayOneLine were False.
showMixedAmountLinesB :: AmountDisplayOpts -> MixedAmount -> [ WideBuilder ]
showMixedAmountLinesB opts @ AmountDisplayOpts { displayMaxWidth = mmax , displayMinWidth = mmin } ma =
map ( adBuilder . pad ) elided
where
2021-07-22 21:04:59 +03:00
astrs = amtDisplayList ( wbWidth sep ) ( showAmountB opts ) . orderedAmounts opts $
2021-04-12 15:50:56 +03:00
if displayPrice opts then ma else mixedAmountStripPrices ma
sep = WideBuilder ( TB . singleton '\ n' ) 0
2021-07-22 21:04:59 +03:00
width = maximum $ map ( wbWidth . adBuilder ) elided
2021-04-12 15:50:56 +03:00
2021-07-22 21:04:59 +03:00
pad amt
| Just mw <- mmin =
let w = ( max width mw ) - wbWidth ( adBuilder amt )
in amt { adBuilder = WideBuilder ( TB . fromText $ T . replicate w " " ) w <> adBuilder amt }
| otherwise = amt
2021-04-12 15:50:56 +03:00
elided = maybe id elideTo mmax astrs
elideTo m xs = maybeAppend elisionStr short
where
elisionStr = elisionDisplay ( Just m ) ( wbWidth sep ) ( length long ) $ lastDef nullAmountDisplay short
( short , long ) = partition ( ( m >= ) . wbWidth . adBuilder ) xs
-- | Helper for showMixedAmountB to deal with single line displays. This does not
-- honour displayOneLine: all amounts will be displayed as if displayOneLine
-- were True.
showMixedAmountOneLineB :: AmountDisplayOpts -> MixedAmount -> WideBuilder
showMixedAmountOneLineB opts @ AmountDisplayOpts { displayMaxWidth = mmax , displayMinWidth = mmin } ma =
WideBuilder ( wbBuilder . pad . mconcat . intersperse sep $ map adBuilder elided )
. max width $ fromMaybe 0 mmin
where
width = maybe 0 adTotal $ lastMay elided
2021-07-22 21:04:59 +03:00
astrs = amtDisplayList ( wbWidth sep ) ( showAmountB opts ) . orderedAmounts opts $
2021-04-12 15:50:56 +03:00
if displayPrice opts then ma else mixedAmountStripPrices ma
sep = WideBuilder ( TB . fromString " , " ) 2
n = length astrs
pad = ( WideBuilder ( TB . fromText $ T . replicate w " " ) w <> )
where w = fromMaybe 0 mmin - width
elided = maybe id elideTo mmax astrs
elideTo m = addElide . takeFitting m . withElided
-- Add the last elision string to the end of the display list
addElide [] = []
addElide xs = maybeAppend ( snd $ last xs ) $ map fst xs
-- Return the elements of the display list which fit within the maximum width
-- (including their elision strings). Always display at least one amount,
-- regardless of width.
takeFitting _ [] = []
takeFitting m ( x : xs ) = x : dropWhileRev ( \ ( a , e ) -> m < adTotal ( fromMaybe a e ) ) xs
dropWhileRev p = foldr ( \ x xs -> if null xs && p x then [] else x : xs ) []
-- Add the elision strings (if any) to each amount
withElided = zipWith ( \ num amt -> ( amt , elisionDisplay Nothing ( wbWidth sep ) num amt ) ) [ n - 1 , n - 2 .. 0 ]
2020-09-14 09:22:07 +03:00
2021-07-22 21:04:59 +03:00
orderedAmounts :: AmountDisplayOpts -> MixedAmount -> [ Amount ]
2021-11-12 13:26:50 +03:00
orderedAmounts dopts = maybe id ( mapM pad ) ( displayOrder dopts ) . amounts
2021-07-22 21:04:59 +03:00
where
2021-11-12 13:26:50 +03:00
pad c = fromMaybe ( amountWithCommodity c nullamt ) . find ( ( c == ) . acommodity )
2021-07-22 21:04:59 +03:00
2020-09-14 09:22:07 +03:00
data AmountDisplay = AmountDisplay
2020-12-22 15:35:20 +03:00
{ adBuilder :: ! WideBuilder -- ^ String representation of the Amount
, adTotal :: ! Int -- ^ Cumulative length of MixedAmount this Amount is part of,
-- including separators
2021-04-14 01:07:38 +03:00
} deriving ( Show )
2020-10-26 05:19:50 +03:00
nullAmountDisplay :: AmountDisplay
2020-12-22 15:35:20 +03:00
nullAmountDisplay = AmountDisplay mempty 0
2020-09-14 09:22:07 +03:00
2020-12-22 15:35:20 +03:00
amtDisplayList :: Int -> ( Amount -> WideBuilder ) -> [ Amount ] -> [ AmountDisplay ]
2020-09-14 09:22:07 +03:00
amtDisplayList sep showamt = snd . mapAccumL display ( - sep )
where
2020-12-22 15:35:20 +03:00
display tot amt = ( tot' , AmountDisplay str tot' )
2020-06-26 22:14:49 +03:00
where
2020-09-14 09:22:07 +03:00
str = showamt amt
2020-12-22 15:35:20 +03:00
tot' = tot + ( wbWidth str ) + sep
2020-09-14 09:22:07 +03:00
-- The string "m more", added to the previous running total
elisionDisplay :: Maybe Int -> Int -> Int -> AmountDisplay -> Maybe AmountDisplay
elisionDisplay mmax sep n lastAmt
2020-12-22 15:35:20 +03:00
| n > 0 = Just $ AmountDisplay ( WideBuilder ( TB . fromText str ) len ) ( adTotal lastAmt + len )
2020-09-14 09:22:07 +03:00
| otherwise = Nothing
where
2020-12-22 15:35:20 +03:00
fullString = T . pack $ show n ++ " more.. "
2020-09-14 09:22:07 +03:00
-- sep from the separator, 7 from " more..", 1 + floor (logBase 10 n) from number
fullLength = sep + 8 + floor ( logBase 10 $ fromIntegral n )
2020-12-22 15:35:20 +03:00
str | Just m <- mmax , fullLength > m = T . take ( m - 2 ) fullString <> " .. "
2020-09-14 09:22:07 +03:00
| otherwise = fullString
len = case mmax of Nothing -> fullLength
Just m -> max 2 $ min m fullLength
maybeAppend :: Maybe a -> [ a ] -> [ a ]
maybeAppend Nothing = id
maybeAppend ( Just a ) = ( ++ [ a ] )
-- | Compact labelled trace of a mixed amount, for debugging.
ltraceamount :: String -> MixedAmount -> MixedAmount
2021-09-02 12:56:29 +03:00
ltraceamount s a = trace ( s ++ " : " ++ showMixedAmount a ) a
2020-09-14 09:22:07 +03:00
-- | Set the display precision in the amount's commodities.
2021-02-05 00:57:55 +03:00
mixedAmountSetPrecision :: AmountPrecision -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mixedAmountSetPrecision p = mapMixedAmountUnsafe ( amountSetPrecision p )
2021-02-05 00:57:55 +03:00
-- | In each component amount, increase the display precision sufficiently
-- to render it exactly (showing all significant decimal digits).
mixedAmountSetFullPrecision :: MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mixedAmountSetFullPrecision = mapMixedAmountUnsafe amountSetFullPrecision
2020-09-14 09:22:07 +03:00
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
-- | Remove all prices from a MixedAmount.
2020-09-14 09:22:07 +03:00
mixedAmountStripPrices :: MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
mixedAmountStripPrices ( Mixed ma ) =
foldl' ( \ m a -> maAddAmount m a { aprice = Nothing } ) ( Mixed noPrices ) withPrices
where ( noPrices , withPrices ) = M . partition ( isNothing . aprice ) ma
2020-06-26 22:14:49 +03:00
2012-11-20 01:20:10 +04:00
-- | Canonicalise a mixed amount's display styles using the provided commodity style map.
2016-05-08 02:18:04 +03:00
canonicaliseMixedAmount :: M . Map CommoditySymbol AmountStyle -> MixedAmount -> MixedAmount
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
canonicaliseMixedAmount styles = mapMixedAmountUnsafe ( canonicaliseAmount styles )
2012-11-20 01:20:10 +04:00
2018-11-14 02:37:42 +03:00
-- | Replace each component amount's TotalPrice, if it has one, with an equivalent UnitPrice.
2019-07-15 13:28:52 +03:00
-- Has no effect on amounts without one.
2018-11-14 02:37:42 +03:00
-- Does Decimal division, might be some rounding/irrational number issues.
mixedAmountTotalPriceToUnitPrice :: MixedAmount -> MixedAmount
2021-01-25 23:41:53 +03:00
mixedAmountTotalPriceToUnitPrice = mapMixedAmount amountTotalPriceToUnitPrice
2018-11-14 02:37:42 +03:00
2018-04-20 22:18:28 +03:00
2011-08-31 20:54:10 +04:00
-------------------------------------------------------------------------------
2018-09-04 20:01:26 +03:00
-- tests
2021-08-30 08:23:23 +03:00
tests_Amount = testGroup " Amount " [
testGroup " Amount " [
2018-09-04 20:01:26 +03:00
2021-08-30 08:23:23 +03:00
testCase " amountCost " $ do
2020-06-01 01:48:08 +03:00
amountCost ( eur 1 ) @?= eur 1
amountCost ( eur 2 ) { aprice = Just $ UnitPrice $ usd 2 } @?= usd 4
amountCost ( eur 1 ) { aprice = Just $ TotalPrice $ usd 2 } @?= usd 2
2021-01-06 12:46:31 +03:00
amountCost ( eur ( - 1 ) ) { aprice = Just $ TotalPrice $ usd ( - 2 ) } @?= usd ( - 2 )
2019-11-27 23:46:29 +03:00
2021-08-30 08:23:23 +03:00
, testCase " amountLooksZero " $ do
2020-05-30 04:57:22 +03:00
assertBool " " $ amountLooksZero amount
assertBool " " $ amountLooksZero $ usd 0
2019-11-27 23:46:29 +03:00
2021-08-30 08:23:23 +03:00
, testCase " negating amounts " $ do
2019-11-27 23:46:29 +03:00
negate ( usd 1 ) @?= ( usd 1 ) { aquantity = - 1 }
let b = ( usd 1 ) { aprice = Just $ UnitPrice $ eur 2 } in negate b @?= b { aquantity = - 1 }
2021-08-30 08:23:23 +03:00
, testCase " adding amounts without prices " $ do
2019-11-27 23:46:29 +03:00
( usd 1.23 + usd ( - 1.23 ) ) @?= usd 0
( usd 1.23 + usd ( - 1.23 ) ) @?= usd 0
( usd ( - 1.23 ) + usd ( - 1.23 ) ) @?= usd ( - 2.46 )
sum [ usd 1.23 , usd ( - 1.23 ) , usd ( - 1.23 ) , - ( usd ( - 1.23 ) ) ] @?= usd 0
-- highest precision is preserved
2020-08-13 14:15:41 +03:00
asprecision ( astyle $ sum [ usd 1 ` withPrecision ` Precision 1 , usd 1 ` withPrecision ` Precision 3 ] ) @?= Precision 3
asprecision ( astyle $ sum [ usd 1 ` withPrecision ` Precision 3 , usd 1 ` withPrecision ` Precision 1 ] ) @?= Precision 3
2019-11-27 23:46:29 +03:00
-- adding different commodities assumes conversion rate 1
2020-05-30 04:57:22 +03:00
assertBool " " $ amountLooksZero ( usd 1.23 - eur 1.23 )
2019-11-27 23:46:29 +03:00
2021-08-30 08:23:23 +03:00
, testCase " showAmount " $ do
2019-11-27 23:46:29 +03:00
showAmount ( usd 0 + gbp 0 ) @?= " 0 "
2011-04-22 17:40:55 +04:00
2010-03-09 07:03:51 +03:00
]
2018-09-04 20:01:26 +03:00
2021-08-30 08:23:23 +03:00
, testGroup " MixedAmount " [
2018-09-04 20:01:26 +03:00
2021-08-30 08:23:23 +03:00
testCase " comparing mixed amounts compares based on quantities " $ do
2021-07-13 10:11:50 +03:00
let usdpos = mixed [ usd 1 ]
usdneg = mixed [ usd ( - 1 ) ]
eurneg = mixed [ eur ( - 12 ) ]
compare usdneg usdpos @?= LT
compare eurneg usdpos @?= LT
2021-08-30 08:23:23 +03:00
, testCase " adding mixed amounts to zero, the commodity and amount style are preserved " $
2021-01-29 15:34:18 +03:00
maSum ( map mixedAmount
[ usd 1.25
, usd ( - 1 ) ` withPrecision ` Precision 3
, usd ( - 0.25 )
] )
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
@?= mixedAmount ( usd 0 ` withPrecision ` Precision 3 )
2019-07-15 13:28:52 +03:00
2021-08-30 08:23:23 +03:00
, testCase " adding mixed amounts with total prices " $ do
2021-01-29 15:34:18 +03:00
maSum ( map mixedAmount
[ usd 1 @@ eur 1
, usd ( - 2 ) @@ eur 1
] )
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
@?= mixedAmount ( usd ( - 1 ) @@ eur 2 )
2019-07-15 13:28:52 +03:00
2021-08-30 08:23:23 +03:00
, testCase " showMixedAmount " $ do
2021-01-31 07:23:46 +03:00
showMixedAmount ( mixedAmount ( usd 1 ) ) @?= " $1.00 "
showMixedAmount ( mixedAmount ( usd 1 ` at ` eur 2 ) ) @?= " $1.00 @ €2.00 "
showMixedAmount ( mixedAmount ( usd 0 ) ) @?= " 0 "
showMixedAmount nullmixedamt @?= " 0 "
2019-11-27 23:46:29 +03:00
showMixedAmount missingmixedamt @?= " "
2019-07-15 13:28:52 +03:00
2021-08-30 08:23:23 +03:00
, testCase " showMixedAmountWithoutPrice " $ do
2019-11-27 23:46:29 +03:00
let a = usd 1 ` at ` eur 2
2021-01-31 07:23:46 +03:00
showMixedAmountWithoutPrice False ( mixedAmount ( a ) ) @?= " $1.00 "
showMixedAmountWithoutPrice False ( mixed [ a , - a ] ) @?= " 0 "
2019-07-15 13:28:52 +03:00
2021-08-30 08:23:23 +03:00
, testGroup " amounts " [
testCase " a missing amount overrides any other amounts " $
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts ( mixed [ usd 1 , missingamt ] ) @?= [ missingamt ]
2021-08-30 08:23:23 +03:00
, testCase " unpriced same-commodity amounts are combined " $
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts ( mixed [ usd 0 , usd 2 ] ) @?= [ usd 2 ]
2021-08-30 08:23:23 +03:00
, testCase " amounts with same unit price are combined " $
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts ( mixed [ usd 1 ` at ` eur 1 , usd 1 ` at ` eur 1 ] ) @?= [ usd 2 ` at ` eur 1 ]
2021-08-30 08:23:23 +03:00
, testCase " amounts with different unit prices are not combined " $
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts ( mixed [ usd 1 ` at ` eur 1 , usd 1 ` at ` eur 2 ] ) @?= [ usd 1 ` at ` eur 1 , usd 1 ` at ` eur 2 ]
2021-08-30 08:23:23 +03:00
, testCase " amounts with total prices are combined " $
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts ( mixed [ usd 1 @@ eur 1 , usd 1 @@ eur 1 ] ) @?= [ usd 2 @@ eur 2 ]
2018-09-04 20:01:26 +03:00
]
2019-07-15 13:28:52 +03:00
2021-08-30 08:23:23 +03:00
, testCase " mixedAmountStripPrices " $ do
lib: Change internal representation of MixedAmount to use a strict Map
instead of a list of Amounts. No longer export Mixed constructor, to
keep API clean (if you really need it, you can import it directly from
Hledger.Data.Types). We also ensure the JSON representation of
MixedAmount doesn't change: it is stored as a normalised list of
Amounts.
This commit improves performance. Here are some indicative results.
hledger reg -f examples/10000x1000x10.journal
- Maximum residency decreases from 65MB to 60MB (8% decrease)
- Total memory in use decreases from 178MiB to 157MiB (12% decrease)
hledger reg -f examples/10000x10000x10.journal
- Maximum residency decreases from 69MB to 60MB (13% decrease)
- Total memory in use decreases from 198MiB to 153MiB (23% decrease)
hledger bal -f examples/10000x1000x10.journal
- Total heap usage decreases from 6.4GB to 6.0GB (6% decrease)
- Total memory in use decreases from 178MiB to 153MiB (14% decrease)
hledger bal -f examples/10000x10000x10.journal
- Total heap usage decreases from 7.3GB to 6.9GB (5% decrease)
- Total memory in use decreases from 196MiB to 185MiB (5% decrease)
hledger bal -M -f examples/10000x1000x10.journal
- Total heap usage decreases from 16.8GB to 10.6GB (47% decrease)
- Total time decreases from 14.3s to 12.0s (16% decrease)
hledger bal -M -f examples/10000x10000x10.journal
- Total heap usage decreases from 108GB to 48GB (56% decrease)
- Total time decreases from 62s to 41s (33% decrease)
If you never directly use the constructor Mixed or pattern match against
it then you don't need to make any changes. If you do, then do the
following:
- If you really care about the individual Amounts and never normalise
your MixedAmount (for example, just storing `Mixed amts` and then
extracting `amts` as a pattern match, then use should switch to using
[Amount]. This should just involve removing the `Mixed` constructor.
- If you ever call `mixed`, `normaliseMixedAmount`, or do any sort of
amount arithmetic (+), (-), then you should replace the constructor
`Mixed` with the function `mixed`. To extract the list of Amounts, use
the function `amounts`.
- If you ever call `normaliseMixedAmountSquashPricesForDisplay`, you can
replace that with `mixedAmountStripPrices`. (N.B. this does something
slightly different from `normaliseMixedAmountSquashPricesForDisplay`,
but I don't think there's any use case for squashing prices and then
keeping the first of the squashed prices around. If you disagree let
me know.)
- Any remaining calls to `normaliseMixedAmount` can be removed, as that
is now the identity function.
2021-01-29 08:07:11 +03:00
amounts ( mixedAmountStripPrices nullmixedamt ) @?= [ nullamt ]
assertBool " " $ mixedAmountLooksZero $ mixedAmountStripPrices
2021-01-31 07:23:46 +03:00
( mixed [ usd 10
2018-09-04 20:01:26 +03:00
, usd 10 @@ eur 7
, usd ( - 10 )
2021-01-31 07:23:46 +03:00
, usd ( - 10 ) @@ eur ( - 7 )
2018-09-04 20:01:26 +03:00
] )
]
]