The cambl Reference Manual

This is the cambl Reference Manual, version 4.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 03:32:38 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 cambl

A library for working with financial amounts involving multiple commodities.

Maintainer

Christophe Junke <>

Author

Johh Wiegley <>

License

BSD-3

Version

4.0.0

Dependencies
  • cl-containers (system).
  • local-time (system).
  • periods (system).
  • fprog (system).
  • alexandria (system).
Source

cambl.asd.

Child Component

cambl.lisp (file).


2.2 fprog

Functional programming utilities: iteration over immutable lists sharing identical sublists.

Maintainer

Christophe Junke <>

Author

Johh Wiegley <>

License

BSD-3

Version

1.0.0

Source

fprog.asd.

Child Component

fprog.lisp (file).


3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 cambl/cambl.asd

Source

cambl.asd.

Parent Component

cambl (system).

ASDF Systems

cambl.


3.1.2 fprog/fprog.asd

Source

fprog.asd.

Parent Component

fprog (system).

ASDF Systems

fprog.


3.1.3 cambl/cambl.lisp

Source

cambl.asd.

Parent Component

cambl (system).

Packages

cambl.

Public Interface
Internals

3.1.4 fprog/fprog.lisp

Source

fprog.asd.

Parent Component

fprog (system).

Packages

fprog.

Public Interface
Internals

timing-tests (function).


4 Packages

Packages are listed by definition order.


4.1 fprog

Source

fprog.lisp.

Use List

common-lisp.

Public Interface
Internals

timing-tests (function).


4.2 cambl

Source

cambl.lisp.

Use List
  • alexandria.
  • common-lisp.
  • local-time.
  • periods.
Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Special variables

Special Variable: *default-commodity-pool*
Package

cambl.

Source

cambl.lisp.

Special Variable: *default-display-precision*
Package

cambl.

Source

cambl.lisp.

Special Variable: *extra-precision*
Package

cambl.

Source

cambl.lisp.


5.1.2 Macros

Macro: apply-to-list (list predicate function &key first-only skip-to-next lookahead)

Given an input LIST, replicate as much of its structure as possible
while applying some kind of transform on its value.

For every member of the list where PREDICATE returns T, FUNCTION is called with the list whose CAR is that member; FUNCTION should return the list which will be substituted at that point (this makes it possible to remove, change or insert the matched cell). If FIRST-ONLY is NIL, this is only done for every cell that matches. Note: Be very careful when setting FIRST-ONLY to T, for if FUNCTION returns a new list that also matches PREDICATE, an infinitely recursive loop can occur. If SKIP-TO-NEXT is T, scanning the function contains with the CDR of the value returned by FUNCTION, which can never lead to infinite recursion. If LOOKAHEAD is T, the list is prescanned to see if PREDICATE matches, otherwise copying is done regardless of whether there is a match in LIST or not; this mimics the behavior of CL:MAPCAR and is better for very short lists.

This function depends on the following contract with the caller:

1. The input LIST is immutable after any call to APPLY-TO-LIST until
the end of the program.

2. The returned LIST is likewise immutable.

The memory savings offered by this function comes at two costs: The first is the subsequent immutability of the input data, and the second is an increase in functional complexity. Specifically, while CL:MAPCAR is O(N) for a given list, FPROG:APPLY-TO-LIST – when used to implement a sharing form of MAPCAR, such as FPROG:MAPCAR-IF – has complexity O(N) in the best case, and O(2N) in the worst case when LOOKAHEAD is T, otherwise it is also O(N) (where an element to be substituted occurs at the very end of the list).

Now, the cost of speed in the worst case can lead to dramatic improvements in memory usage in the average case, with an attendant speed advantage. Take the case of a list which is 500 elements long. In my environment, here are the timings for using MAPCAR to generate a new list from an old one where only one cons cell needs to be changed. These times were determined by calling the same code repeatedly 1,000,000 times (that code is near the end of this file, in the function TIMING-TESTS):

Evaluation took:
8.367 seconds of real time
7.931782 seconds of user run time
0.342331 seconds of system run time
[Run times include 2.679 seconds GC run time.]
0 calls to %EVAL
0 page faults and
4,024,029,056 bytes consed.

That’s 4 gigabytes of memory, probably to be expected. The only reason this doesn’t blow the heap is because all of the intermediate results are being thrown away, making a lot of the cons’ing "free". If the results are kept, the MAPCAR solution becomes impossible without dramatically increasing Lisp’s heap size.

The memory and time costs of using MAPCAR in this example are constant no matter whether the cons cell is substituted at the beginning, middle or end of the 500 element list. To compare, here are the time and memory statistics from FPROG:MAPCAR-IF for the same data, in all three cases (best, average, worst):

Evaluation took:
3.478 seconds of real time
3.474324 seconds of user run time
0.003887 seconds of system run time
[Run times include 0.026 seconds GC run time.]
0 calls to %EVAL
0 page faults and
40,007,952 bytes consed.

In the best case, memory usage is reduced by two orders of magnitude, with an appreciable boost in speed. If the results of this case are saved (using COLLECT in the LOOP instead of DO), the speed savings can become dramatic. Note also that except for the immutability constraints, the results from the two different approaches are EQUAL.

Evaluation took:
7.495 seconds of real time
7.272269 seconds of user run time
0.173947 seconds of system run time
[Run times include 1.416 seconds GC run time.]
0 calls to %EVAL
0 page faults and
2,032,015,008 bytes consed.

In the average case (middle of the list), memory usage is cut in half, while runtime speed is still faster. The cons’ing of CL:MAPCAR also gets more expensive the more the results are kept, so this trivial speed tests – where no results are saved – is not exactly fair between the two. But even still FPROG:MAPCAR-IF is doing well.

Evaluation took:
11.343 seconds of real time
10.969349 seconds of user run time
0.327477 seconds of system run time
[Run times include 2.679 seconds GC run time.]
0 calls to %EVAL
0 page faults and
4,024,030,568 bytes consed.

Finally, the pathological case, where MAPCAR-IF degenerates into an exact duplicate of MAPCAR. Memory use is the same, but speed is much slower because the call to MEMBER-IF is searching the entire list before we decide that all of it needs duplication.

Below are possible FUNCTION arguments relating to the three canonical uses of APPLY-TO-LIST, plus the names of provided convenience functions which offer simple implementations of them:

1. Modify an existing element: #’(lambda (list) (cons new-cons (cdr list)))

Use: (FPROG:MAPCAR-IF predicate function list)

2. Remove an existing element: #’(lambda (list) (cdr list))

Use: (FPROG:REMOVE-IF predicate list)

3. Add a new element: #’(lambda (list) (cons new-cons list))

Use: (FPROG:INSERT-IF predicate function list)

Note: When removing elements, SKIP-TO-NEXT must be set to NIL, otherwise further matching elements might be missed. For modifying and adding elements, SKIP-TO-NEXT is likely to always be T (the default).

The functionality offered by APPLY-TO-LIST is that every cons cell from the original LIST, after the last matching member, is shared entirely. This is quite different from COPY-LIST, which creates new cons cells for every position – even those that do not require a unique structure. For example, consider the following list:

(defparameter *alist* ’((a . 1) (b . 2) (e . 3) (f . 6) (g . 7)))

The idea is to return another version of this immutable list, while sharing as much structure as possible – because the return value is also considered immutable. The following function call achieves this, using the Modify pattern from above:

(apply-to-list *alist* #’(lambda (member) (eq ’e (car member))) #’(lambda (list) (cons (cons (caar list) 5)
(cdr list))))
=> ’((a . 1) (b . 2) (e . 5) (f . 6) (g . 7))

In the returned list, 15 atoms are shared with the original, while one new cons cell and one new atom are created:

1, 2, 3: (a . 1)
4, 5, 6: (b . 2)
7: e
8, 9, 10 11: ((f . 6) ...)
12, 13, 14, 15: ((g . 7))

The usual practice of calling MAPCAR and changing the incorrect element would have result in sharing only 13 atoms. That code might have looked like this:

(mapcar #’(lambda (cell)
(if (eq ’e (car cell))
(cons (car cell) 5)
cell)) *alist*)

Further, while a discrepancy of 2 cons cells may not seem like much in this example, the difference increases by one for every cell beyond the cell that matches. Thus, if the input list had contained 100 cells beyond (e . 3), the difference would have been 102 cells, and not merely 2.

Finally, in our example exactly 4 new cons cells and 1 new atom were created as a result of the call:

1: ((a . 1) ...)
2: ((b . 2) ...)
3: ((e . 5) ...)
4: (e . 5)
5: 5

This is the minimum amount of new information required to represent a new structure where the only change is that ’e’ is paired with 5 instead of 3.

The idea of APPLY-TO-LIST is to support efficient functional programming, whereat immutable outputs are derived from immutable inputs by efficiently sharing as much structure as possible – resulting in the least new memory allocated. In cases where no references are held, this offers little gain over advanced generational garbage collection (such as lists passed within a recursive function); but where the results are held over the longer term, such as a series of computed values stored in a results list, the savings of this function can become substantial. It was exactly this kind of sitation that motivated APPLY-TO-LIST: it made it possible to reduce overall memory consumption by a factor of 20, without introducing any additional complexity into the calling code.

Package

fprog.

Source

fprog.lisp.

Macro: pushend (item the-list &optional final-cons)
Package

cambl.

Source

cambl.lisp.


5.1.3 Ordinary functions

Function: amount (string &key pool)
Package

cambl.

Source

cambl.lisp.

Function: amount* (string &key pool)
Package

cambl.

Source

cambl.lisp.

Reader: amount-commodity (instance)
Writer: (setf amount-commodity) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

commodity.

Function: amount-in-balance (balance commodity)
Package

cambl.

Source

cambl.lisp.

Reader: amount-keep-precision-p (instance)
Writer: (setf amount-keep-precision-p) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

keep-precision-p.

Function: amount-p (object)
Package

cambl.

Source

cambl.lisp.

Reader: amount-quantity (instance)
Writer: (setf amount-quantity) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

quantity.

Function: annotated-commodity-p (object)
Package

cambl.

Source

cambl.lisp.

Reader: annotation-date (instance)
Writer: (setf annotation-date) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

date.

Reader: annotation-price (instance)
Writer: (setf annotation-price) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

price.

Reader: annotation-tag (instance)
Writer: (setf annotation-tag) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

tag.

Function: balance-amounts (balance)
Package

cambl.

Source

cambl.lisp.

Function: balance-commodities (balance)
Package

cambl.

Source

cambl.lisp.

Function: balance-commodity-count (balance)
Package

cambl.

Source

cambl.lisp.

Function: balance-first-amount (balance)
Package

cambl.

Source

cambl.lisp.

Function: balance-p (object)
Package

cambl.

Source

cambl.lisp.

Function: commodity-builtin-p (comm)
Setf Expander: (setf commodity-builtin-p) (comm)
Package

cambl.

Source

cambl.lisp.

Function: commodity-equal (a b)

Two commodities are EQUAL if they are the same object.

Package

cambl.

Source

cambl.lisp.

Function: commodity-equalp (a b)
Package

cambl.

Source

cambl.lisp.

Function: commodity-european-style-p (comm)
Setf Expander: (setf commodity-european-style-p) (comm)
Package

cambl.

Source

cambl.lisp.

Function: commodity-lessp (left right)

Return T if commodity LEFT should be sorted before RIGHT.

Package

cambl.

Source

cambl.lisp.

Function: commodity-no-market-price-p (comm)
Setf Expander: (setf commodity-no-market-price-p) (comm)
Package

cambl.

Source

cambl.lisp.

Function: commodity-pool (comm)
Setf Expander: (setf commodity-pool) (comm)
Package

cambl.

Source

cambl.lisp.

Function: commodity-price-history (comm)
Setf Expander: (setf commodity-price-history) (comm)
Package

cambl.

Source

cambl.lisp.

Function: commodity-thousand-marks-p (comm)
Setf Expander: (setf commodity-thousand-marks-p) (comm)
Package

cambl.

Source

cambl.lisp.

Function: compare-amounts-visually (left right)
Package

cambl.

Source

cambl.lisp.

Function: exact-amount (string &key pool)
Package

cambl.

Source

cambl.lisp.

Function: exchange-commodity (amount &key total-cost per-unit-cost moment tag)
Package

cambl.

Source

cambl.lisp.

Function: find-annotated-commodity (name-or-commodity details &key create-if-not-exists-p pool)

Find an annotated commodity matching the commodity symbol NAME, which may be a STRING or a COMMODITY-SYMBOL, and given set of commodity DETAILS, of type COMMODITY-ANNOTATION.

Returns two values: COMMODITY or NIL, NEWLY-CREATED-P

Package

cambl.

Source

cambl.lisp.

Function: find-commodity (name &key create-if-not-exists-p pool)

Find a COMMODITY identifier by the symbol name found by parsing NAME.

The NAME can be either a string or an input stream, or nil, in which case the name is read from *STANDARD-INPUT*.

The argument :POOL specifies the commodity pool which will maintain this commodity, and by which other code may access it again.

The argument :CREATE-IF-NOT-EXISTS-P indicates whether a new commodity should be created if one cannot already be found.

The return values are: COMMODITY or NIL, NEWLY-CREATED-P

Package

cambl.

Source

cambl.lisp.

Reader: get-amounts-map (instance)
Writer: (setf get-amounts-map) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

amounts-map.

Function: insert-if (predicate function list)
Package

fprog.

Source

fprog.lisp.

Function: make-commodity-annotation (&key price date tag)
Package

cambl.

Source

cambl.lisp.

Function: make-commodity-pool (&key by-name-map default-commodity)
Package

cambl.

Source

cambl.lisp.

Function: mapcar-if (predicate function list)
Package

fprog.

Source

fprog.lisp.

Function: parse-amount (&rest args)
Package

cambl.

Source

cambl.lisp.

Function: parse-amount* (&rest args)
Package

cambl.

Source

cambl.lisp.

Function: read-amount (in &key observe-properties-p pool)

Parse an AMOUNT from the input stream IN.

If :OBSERVE-PROPERTIES-P is T (the default), any display details noticed in this amount will be set as defaults for displaying this kind of commodity in the future.

If :POOL is set, any commodities created by this routine (a maximum possible of two, if an annotated price is given with a second commodity) will be associated with the given commodity pool.

The possible syntax for an amount is:

[-]NUM[ ]SYM [ANNOTATION]
SYM[ ][-]NUM [ANNOTATION]

Package

cambl.

Source

cambl.lisp.

Function: read-amount* (in &key pool)
Package

cambl.

Source

cambl.lisp.

Function: read-exact-amount (in &key pool)
Package

cambl.

Source

cambl.lisp.

Function: remove-if (predicate list)
Package

fprog.

Source

fprog.lisp.

Function: reset-commodity-pool (&optional pool)
Package

cambl.

Source

cambl.lisp.

Function: sign (amount)

Return -1, 0 or 1 depending on the sign of AMOUNT.

Package

cambl.

Source

cambl.lisp.

Function: sign* (amount)

Return -1, 0 or 1 depending on the sign of AMOUNT.

Package

cambl.

Source

cambl.lisp.

Function: value-greatereqp (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-greatereqp* (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-greaterp (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-greaterp* (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-lesseqp (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-lesseqp* (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-lessp (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-lessp* (left right)
Package

cambl.

Source

cambl.lisp.

Function: value-maybe-round (amount)
Package

cambl.

Source

cambl.lisp.

Function: value-round (amount &optional precision)

Round the given AMOUNT to the stated PRECISION.

If PRECISION is less than the current internal precision, data will be lost. If it is greater, this operation has no effect.

Package

cambl.

Source

cambl.lisp.

Function: value< (left right)
Package

cambl.

Source

cambl.lisp.

Function: value<= (left right)
Package

cambl.

Source

cambl.lisp.

Function: value> (left right)
Package

cambl.

Source

cambl.lisp.

Function: value>= (left right)
Package

cambl.

Source

cambl.lisp.

Function: valuep (object)
Package

cambl.

Source

cambl.lisp.


5.1.4 Generic functions

Generic Function: add (value-a value-b)
Package

cambl.

Source

cambl.lisp.

Methods
Method: add ((left balance) (right balance))
Method: add ((left balance) (right amount))
Method: add ((left balance) (right rational))
Method: add ((left amount) (right balance))
Method: add ((left amount) (right amount))
Method: add ((left amount) (right rational))
Method: add ((left rational) (right balance))
Method: add ((left rational) (right amount))
Method: add ((left rational) (right rational))
Generic Function: amount-precision (item)
Package

cambl.

Source

cambl.lisp.

Methods
Method: amount-precision ((item amount))
Method: amount-precision ((item rational))
Generic Function: annotate-commodity (item annotation)
Package

cambl.

Source

cambl.lisp.

Methods
Method: annotate-commodity ((amount amount) (details commodity-annotation))
Method: annotate-commodity ((commodity commodity) (details commodity-annotation))
Generic Function: commodity-annotation (item)
Package

cambl.

Source

cambl.lisp.

Methods
Method: commodity-annotation ((amount amount))
Method: commodity-annotation ((annotated-commodity annotated-commodity))
Method: commodity-annotation ((commodity commodity))
Generic Function: commodity-annotation-equal (left-item right-item)
Package

cambl.

Source

cambl.lisp.

Methods
Method: commodity-annotation-equal ((a commodity-annotation) (b commodity-annotation))
Generic Function: commodity-name (item &optional no-annotation)
Package

cambl.

Source

cambl.lisp.

Methods
Method: commodity-name ((amount amount) &optional no-annotation)
Method: commodity-name ((commodity commodity) &optional no-annotation)
Method: commodity-name ((null null) &optional no-annotation)
Generic Reader: commodity-qualified-name (object)
Package

cambl.

Methods
Reader Method: commodity-qualified-name ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

qualified-name.

Generic Writer: (setf commodity-qualified-name) (object)
Package

cambl.

Methods
Writer Method: (setf commodity-qualified-name) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

qualified-name.

Generic Function: compare (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: compare ((left amount) (right amount))
Method: compare ((left rational) (right amount))
Method: compare ((left amount) (right rational))
Method: compare ((left rational) (right rational))
Generic Function: compare* (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: compare* ((left amount) (right amount))
Method: compare* ((left rational) (right amount))
Method: compare* ((left amount) (right rational))
Method: compare* ((left rational) (right rational))
Generic Function: display-precision (item)
Package

cambl.

Source

cambl.lisp.

Methods
Method: display-precision ((amount amount))
Method: display-precision ((annotated-commodity annotated-commodity))
Method: display-precision ((commodity commodity))
Generic Function: divide (value-a value-b)
Package

cambl.

Source

cambl.lisp.

Methods
Method: divide ((left balance) (right amount))
Method: divide ((left balance) (right rational))
Method: divide ((left amount) (right amount))
Method: divide ((left amount) (right rational))
Method: divide ((left rational) (right balance))
Method: divide ((left rational) (right amount))
Method: divide ((left rational) (right rational))
Generic Function: format-value (value &key omit-commodity-p full-precision-p width latter-width line-feed-string)
Package

cambl.

Source

cambl.lisp.

Methods
Method: format-value ((balance balance) &key omit-commodity-p full-precision-p width latter-width line-feed-string)
Method: format-value ((amount amount) &key omit-commodity-p full-precision-p width latter-width line-feed-string)
Method: format-value ((rational rational) &key omit-commodity-p full-precision-p width latter-width line-feed-string)
Generic Function: market-value (any-item &optional fixed-time)
Package

cambl.

Source

cambl.lisp.

Methods
Method: market-value ((balance balance) &optional fixed-time)
Method: market-value ((amount amount) &optional fixed-time)
Method: market-value ((rational rational) &optional fixed-time)
Method: market-value ((annotated-commodity annotated-commodity) &optional fixed-time)
Method: market-value ((commodity commodity) &optional fixed-time)
Generic Function: multiply (value-a value-b)
Package

cambl.

Source

cambl.lisp.

Methods
Method: multiply ((left balance) (right amount))
Method: multiply ((left balance) (right rational))
Method: multiply ((left amount) (right amount))
Method: multiply ((left amount) (right rational))
Method: multiply ((left rational) (right balance))
Method: multiply ((left rational) (right amount))
Method: multiply ((left rational) (right rational))
Generic Function: negate (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: negate ((balance balance))
Method: negate ((amount amount))
Method: negate ((rational rational))
Generic Function: print-value (value &key output-stream omit-commodity-p full-precision-p width latter-width line-feed-string)
Package

cambl.

Source

cambl.lisp.

Methods
Method: print-value ((balance balance) &key output-stream omit-commodity-p full-precision-p width latter-width line-feed-string)
Method: print-value ((amount amount) &key output-stream omit-commodity-p full-precision-p width latter-width line-feed-string)
Method: print-value ((rational rational) &key output-stream omit-commodity-p full-precision-p width latter-width line-feed-string)
Method: print-value ((integer integer) &key output-stream omit-commodity-p full-precision-p width latter-width line-feed-string)
Generic Function: strip-annotations (any-item &key keep-price keep-date keep-tag)
Package

cambl.

Source

cambl.lisp.

Methods
Method: strip-annotations ((balance balance) &key keep-price keep-date keep-tag)
Method: strip-annotations ((amount amount) &key keep-price keep-date keep-tag)
Method: strip-annotations ((rational rational) &key keep-price keep-date keep-tag)
Method: strip-annotations ((annotated-commodity annotated-commodity) &key keep-price keep-date keep-tag)
Method: strip-annotations ((commodity commodity) &key keep-price keep-date keep-tag)
Generic Function: subtract (value-a value-b)
Package

cambl.

Source

cambl.lisp.

Methods
Method: subtract ((left balance) (right balance))
Method: subtract ((left balance) (right amount))
Method: subtract ((left balance) (right rational))
Method: subtract ((left amount) (right balance))
Method: subtract ((left amount) (right amount))
Method: subtract ((left amount) (right rational))
Method: subtract ((left rational) (right balance))
Method: subtract ((left rational) (right amount))
Method: subtract ((left rational) (right rational))
Generic Function: value-abs (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-abs ((balance balance))
Method: value-abs ((amount amount))
Method: value-abs ((rational rational))
Generic Function: value-equal (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-equal ((left balance) (right balance))
Method: value-equal ((left balance) (right amount))
Method: value-equal ((left balance) (right rational))
Method: value-equal ((left amount) (right balance))
Method: value-equal ((left amount) (right amount))
Method: value-equal ((left amount) (right rational))
Method: value-equal ((left rational) (right balance))
Method: value-equal ((left rational) (right amount))
Method: value-equal ((left rational) (right rational))
Generic Function: value-equalp (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-equalp ((left balance) (right balance))
Method: value-equalp ((left balance) (right amount))
Method: value-equalp ((left balance) (right rational))
Method: value-equalp ((left amount) (right balance))
Method: value-equalp ((left amount) (right amount))
Method: value-equalp ((left amount) (right rational))
Method: value-equalp ((left rational) (right balance))
Method: value-equalp ((left rational) (right amount))
Method: value-equalp ((left rational) (right rational))
Generic Function: value-minusp (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-minusp ((balance balance))
Method: value-minusp ((amount amount))
Method: value-minusp ((rational rational))
Generic Function: value-minusp* (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-minusp* ((balance balance))
Method: value-minusp* ((amount amount))
Method: value-minusp* ((rational rational))
Generic Function: value-not-equal (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-not-equal ((left balance) (right balance))
Method: value-not-equal ((left balance) (right amount))
Method: value-not-equal ((left balance) (right rational))
Method: value-not-equal ((left amount) (right balance))
Method: value-not-equal ((left amount) (right amount))
Method: value-not-equal ((left amount) (right rational))
Method: value-not-equal ((left rational) (right balance))
Method: value-not-equal ((left rational) (right amount))
Method: value-not-equal ((left rational) (right rational))
Generic Function: value-not-equalp (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-not-equalp ((left balance) (right balance))
Method: value-not-equalp ((left balance) (right amount))
Method: value-not-equalp ((left balance) (right rational))
Method: value-not-equalp ((left amount) (right balance))
Method: value-not-equalp ((left amount) (right amount))
Method: value-not-equalp ((left amount) (right rational))
Method: value-not-equalp ((left rational) (right balance))
Method: value-not-equalp ((left rational) (right amount))
Method: value-not-equalp ((left rational) (right rational))
Generic Function: value-plusp (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-plusp ((balance balance))
Method: value-plusp ((amount amount))
Method: value-plusp ((rational rational))
Generic Function: value-plusp* (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-plusp* ((balance balance))
Method: value-plusp* ((amount amount))
Method: value-plusp* ((rational rational))
Generic Function: value-zerop (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-zerop ((balance balance))
Method: value-zerop ((amount amount))
Method: value-zerop ((rational rational))
Generic Function: value-zerop* (value)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value-zerop* ((balance balance))
Method: value-zerop* ((amount amount))
Method: value-zerop* ((rational rational))
Generic Function: value/= (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value/= ((left balance) (right balance))
Method: value/= ((left balance) (right amount))
Method: value/= ((left balance) (right rational))
Method: value/= ((left amount) (right balance))
Method: value/= ((left amount) (right amount))
Method: value/= ((left amount) (right rational))
Method: value/= ((left rational) (right balance))
Method: value/= ((left rational) (right amount))
Method: value/= ((left rational) (right rational))
Generic Function: value= (left right)
Package

cambl.

Source

cambl.lisp.

Methods
Method: value= ((left balance) (right balance))
Method: value= ((left balance) (right amount))
Method: value= ((left balance) (right rational))
Method: value= ((left amount) (right balance))
Method: value= ((left amount) (right amount))
Method: value= ((left amount) (right rational))
Method: value= ((left rational) (right balance))
Method: value= ((left rational) (right amount))
Method: value= ((left rational) (right rational))

5.1.5 Standalone methods

Method: print-object ((annotated-commodity annotated-commodity) stream)
Source

cambl.lisp.

Method: print-object ((object amount) stream)
Source

cambl.lisp.

Method: print-object ((object balance) stream)
Source

cambl.lisp.

Method: print-object ((commodity commodity) stream)
Source

cambl.lisp.


5.1.6 Conditions

Condition: amount-error
Package

cambl.

Source

cambl.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: description
Initargs

:msg

Readers

error-description.

Writers

This slot is read-only.

Slot: operands
Initargs

:operands

Readers

error-operands.

Writers

This slot is read-only.

Condition: commodity-error
Package

cambl.

Source

cambl.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: description
Initargs

:msg

Readers

error-description.

Writers

This slot is read-only.

Slot: commodity
Initform

(quote nil)

Initargs

:commodity

Readers

error-commodity.

Writers

This slot is read-only.


5.1.7 Structures

Structure: amount
Package

cambl.

Source

cambl.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: commodity
Type

(or cambl::commodity null)

Readers

amount-commodity.

Writers

(setf amount-commodity).

Slot: quantity
Type

rational

Initform

0

Readers

amount-quantity.

Writers

(setf amount-quantity).

Slot: full-precision
Type

cambl::fixnum+

Initform

0

Readers

amount-full-precision.

Writers

(setf amount-full-precision).

Slot: keep-precision-p
Type

boolean

Readers

amount-keep-precision-p.

Writers

(setf amount-keep-precision-p).

Structure: commodity-annotation
Package

cambl.

Source

cambl.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: price
Readers

annotation-price.

Writers

(setf annotation-price).

Slot: date
Package

local-time.

Type

(or periods:fixed-time null)

Readers

annotation-date.

Writers

(setf annotation-date).

Slot: tag
Type

(or string null)

Readers

annotation-tag.

Writers

(setf annotation-tag).

Structure: commodity-pool
Package

cambl.

Source

cambl.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: by-name-map
Type

hash-table

Initform

(make-hash-table :test (quote equal))

Readers

commodity-pool-by-name-map.

Writers

(setf commodity-pool-by-name-map).

Slot: default-commodity
Readers

commodity-pool-default-commodity.

Writers

(setf commodity-pool-default-commodity).


5.1.8 Classes

Class: annotated-commodity
Package

cambl.

Source

cambl.lisp.

Direct superclasses

commodity.

Direct methods
Direct slots
Slot: referent
Type

cambl::commodity

Initargs

:referent

Readers

get-referent.

Writers

(setf get-referent).

Slot: annotation
Type

cambl:commodity-annotation

Initargs

:annotation

Readers

get-commodity-annotation.

Writers

(setf get-commodity-annotation).


5.1.9 Types

Type: value ()
Package

cambl.

Source

cambl.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *invalid-symbol-chars*

The invalid commodity symbol characters are:

Space Tab Newline Return
0-9 . , ; - + * / ^ ? : & | ! = "
< > { } [ ] ( ) @

Package

cambl.

Source

cambl.lisp.


5.2.2 Macros

Macro: define-commodity-accessor (function accessor)
Package

cambl.

Source

cambl.lisp.

Macro: transform-balance (balance predicate function &key first-only skip-to-next lookahead)
Package

cambl.

Source

cambl.lisp.


5.2.3 Ordinary functions

Function: add-price (commodity price &optional fixed-time)
Package

cambl.

Source

cambl.lisp.

Reader: amount-full-precision (instance)
Writer: (setf amount-full-precision) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

full-precision.

Function: apply-between-amounts (left right function &optional adjustor)
Package

cambl.

Source

cambl.lisp.

Function: apply-between-balances (left right function &optional adjustor)
Package

cambl.

Source

cambl.lisp.

Function: apply-to-balance (balance commodity value function &optional adjustor)
Package

cambl.

Source

cambl.lisp.

Function: balance (&rest amounts)
Package

cambl.

Source

cambl.lisp.

Function: balance-equal (left right test-func)
Package

cambl.

Source

cambl.lisp.

Function: balance-helper (left right)
Package

cambl.

Source

cambl.lisp.

Function: commodity-annotation-p (object)
Package

cambl.

Source

cambl.lisp.

Function: commodity-comment (comm)
Setf Expander: (setf commodity-comment) (comm)
Package

cambl.

Source

cambl.lisp.

Function: commodity-description (comm)
Setf Expander: (setf commodity-description) (comm)
Package

cambl.

Source

cambl.lisp.

Reader: commodity-pool-by-name-map (instance)
Writer: (setf commodity-pool-by-name-map) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

by-name-map.

Reader: commodity-pool-default-commodity (instance)
Writer: (setf commodity-pool-default-commodity) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

default-commodity.

Function: commodity-pool-p (object)
Package

cambl.

Source

cambl.lisp.

Function: commodity-symbol (comm)
Setf Expander: (setf commodity-symbol) (comm)
Package

cambl.

Source

cambl.lisp.

Reader: commodity-symbol-connected-p (instance)
Writer: (setf commodity-symbol-connected-p) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

connected-p.

Reader: commodity-symbol-name (instance)
Writer: (setf commodity-symbol-name) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

name.

Reader: commodity-symbol-needs-quoting-p (instance)
Writer: (setf commodity-symbol-needs-quoting-p) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

needs-quoting-p.

Function: commodity-symbol-p (object)
Package

cambl.

Source

cambl.lisp.

Reader: commodity-symbol-prefixed-p (instance)
Writer: (setf commodity-symbol-prefixed-p) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

prefixed-p.

Function: copy-amount (instance)
Package

cambl.

Source

cambl.lisp.

Function: copy-balance (instance)
Package

cambl.

Source

cambl.lisp.

Function: copy-commodity-annotation (instance)
Package

cambl.

Source

cambl.lisp.

Function: copy-commodity-pool (instance)
Package

cambl.

Source

cambl.lisp.

Function: copy-commodity-symbol (instance)
Package

cambl.

Source

cambl.lisp.

Function: copy-pricing-entry (instance)
Package

cambl.

Source

cambl.lisp.

Function: create-annotated-commodity (commodity details qualified-name)

Create an ANNOTATED-COMMODITY which annotates COMMODITY.

The NAME can be either a string or a COMMODITY-SYMBOL.

Package

cambl.

Source

cambl.lisp.

Function: create-commodity (name &key pool)

Create a COMMODITY after the symbol name found by parsing NAME.

The NAME can be either a string or an input stream, or nil, in which case the name is read from *STANDARD-INPUT*.

The argument :pool specifies the commodity pool which will maintain this commodity, and by which other code may access it again. The resulting COMMODITY object is returned.

Package

cambl.

Source

cambl.lisp.

Function: divide-in-balance (balance commodity value)
Package

cambl.

Source

cambl.lisp.

Function: find-nearest (history fixed-time)
Package

cambl.

Source

cambl.lisp.

Function: format-commodity-annotation (annotation &key output-stream)

Return the canonical annotation string for ANNOTATION.

A fully annotated commodity always follows the form:

[-]SYMBOL <VALUE> {PRICE} [DATE] (TAG)
or
<VALUE> SYMBOL {PRICE} [DATE] (TAG)

If a particular annotation is not present, those sections is simply dropped from the string, for example:

<VALUE> SYMBOL {PRICE}

Package

cambl.

Source

cambl.lisp.

Function: make-amount (&key commodity quantity full-precision keep-precision-p)
Package

cambl.

Source

cambl.lisp.

Function: make-balance (&key amounts-map)
Package

cambl.

Source

cambl.lisp.

Function: make-commodity-symbol (&key name needs-quoting-p prefixed-p connected-p)
Package

cambl.

Source

cambl.lisp.

Function: make-pricing-entry (&key moment price)
Package

cambl.

Source

cambl.lisp.

Function: make-qualified-name (commodity commodity-annotation)
Package

cambl.

Source

cambl.lisp.

Function: multiply-in-balance (balance commodity value)
Package

cambl.

Source

cambl.lisp.

Function: peek-char-in-line (in &optional skip-whitespace)
Package

cambl.

Source

cambl.lisp.

Reader: pricing-entry-moment (instance)
Writer: (setf pricing-entry-moment) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

moment.

Function: pricing-entry-p (object)
Package

cambl.

Source

cambl.lisp.

Reader: pricing-entry-price (instance)
Writer: (setf pricing-entry-price) (instance)
Package

cambl.

Source

cambl.lisp.

Target Slot

price.

Function: print-amount (amount stream depth)
Package

cambl.

Source

cambl.lisp.

Function: print-balance (balance stream depth)
Package

cambl.

Source

cambl.lisp.

Function: print-value-to-string (commodity commodity-symbol quantity precision output-stream)
Package

cambl.

Source

cambl.lisp.

Function: read-amount-quantity (in)
Package

cambl.

Source

cambl.lisp.

Function: read-commodity-annotation (in)
Package

cambl.

Source

cambl.lisp.

Function: read-commodity-symbol (in)

Parse a commodity symbol from the input stream IN.

This is the correct entry point for creating a new commodity symbol.

A commodity contain any character not found in *INVALID-SYMBOL-CHARS*. To include such characters in a symbol name—except for #\", which may never appear in a symbol name—surround the commodity name with double quotes. It is an error if EOF is reached without reading the ending double quote. If the symbol name is not quoted, and an invalid character is reading, reading from the stream stops and the invalid character is put back.

Package

cambl.

Source

cambl.lisp.

Function: read-until (in char &optional error-message)
Package

cambl.

Source

cambl.lisp.

Function: remove-price (commodity fixed-time)
Package

cambl.

Source

cambl.lisp.

Function: symbol-char-invalid-p (c)
Package

cambl.

Source

cambl.lisp.

Function: symbol-name-needs-quoting-p (name)

Return T if the given symbol NAME requires quoting.

Package

cambl.

Source

cambl.lisp.

Function: timing-tests (&optional loop-count)
Package

fprog.

Source

fprog.lisp.

Function: verify-amounts (left right capitalized-gerund)
Package

cambl.

Source

cambl.lisp.


5.2.4 Generic functions

Generic Function: commodity-annotation-empty-p (item)
Package

cambl.

Source

cambl.lisp.

Methods
Method: commodity-annotation-empty-p ((annotation commodity-annotation))
Generic Reader: error-commodity (condition)
Package

cambl.

Methods
Reader Method: error-commodity ((condition commodity-error))
Source

cambl.lisp.

Target Slot

commodity.

Generic Reader: error-description (condition)
Package

cambl.

Methods
Reader Method: error-description ((condition commodity-error))
Source

cambl.lisp.

Target Slot

description.

Reader Method: error-description ((condition amount-error))
Source

cambl.lisp.

Target Slot

description.

Generic Reader: error-operands (condition)
Package

cambl.

Methods
Reader Method: error-operands ((condition amount-error))
Source

cambl.lisp.

Target Slot

operands.

Generic Reader: get-builtin-p (object)
Package

cambl.

Methods
Reader Method: get-builtin-p ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

builtin-p.

Generic Writer: (setf get-builtin-p) (object)
Package

cambl.

Methods
Writer Method: (setf get-builtin-p) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

builtin-p.

Generic Reader: get-comment (object)
Package

cambl.

Methods
Reader Method: get-comment ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

comment.

Generic Writer: (setf get-comment) (object)
Package

cambl.

Methods
Writer Method: (setf get-comment) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

comment.

Generic Reader: get-commodity-annotation (object)
Package

cambl.

Methods
Reader Method: get-commodity-annotation ((annotated-commodity annotated-commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

annotation.

Generic Writer: (setf get-commodity-annotation) (object)
Package

cambl.

Methods
Writer Method: (setf get-commodity-annotation) ((annotated-commodity annotated-commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

annotation.

Generic Reader: get-commodity-pool (object)
Package

cambl.

Methods
Reader Method: get-commodity-pool ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

commodity-pool.

Generic Writer: (setf get-commodity-pool) (object)
Package

cambl.

Methods
Writer Method: (setf get-commodity-pool) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

commodity-pool.

Generic Reader: get-description (object)
Package

cambl.

Methods
Reader Method: get-description ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

description.

Generic Writer: (setf get-description) (object)
Package

cambl.

Methods
Writer Method: (setf get-description) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

description.

Generic Reader: get-display-precision (object)
Package

cambl.

Methods
Reader Method: get-display-precision ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

display-precision.

Generic Writer: (setf get-display-precision) (object)
Package

cambl.

Methods
Writer Method: (setf get-display-precision) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

display-precision.

Generic Reader: get-european-style-p (object)
Package

cambl.

Methods
Reader Method: get-european-style-p ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

european-style-p.

Generic Writer: (setf get-european-style-p) (object)
Package

cambl.

Methods
Writer Method: (setf get-european-style-p) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

european-style-p.

Generic Reader: get-no-market-price-p (object)
Package

cambl.

Methods
Reader Method: get-no-market-price-p ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

no-market-price-p.

Generic Writer: (setf get-no-market-price-p) (object)
Package

cambl.

Methods
Writer Method: (setf get-no-market-price-p) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

no-market-price-p.

Generic Reader: get-price-history (object)
Package

cambl.

Methods
Reader Method: get-price-history ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

price-history.

Generic Writer: (setf get-price-history) (object)
Package

cambl.

Methods
Writer Method: (setf get-price-history) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

price-history.

Generic Reader: get-referent (object)
Package

cambl.

Methods
Reader Method: get-referent ((annotated-commodity annotated-commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

referent.

Generic Writer: (setf get-referent) (object)
Package

cambl.

Methods
Writer Method: (setf get-referent) ((annotated-commodity annotated-commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

referent.

Generic Reader: get-symbol (object)
Package

cambl.

Methods
Reader Method: get-symbol ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

symbol.

Generic Writer: (setf get-symbol) (object)
Package

cambl.

Methods
Writer Method: (setf get-symbol) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

symbol.

Generic Reader: get-thousand-marks-p (object)
Package

cambl.

Methods
Reader Method: get-thousand-marks-p ((commodity commodity))

automatically generated reader method

Source

cambl.lisp.

Target Slot

thousand-marks-p.

Generic Writer: (setf get-thousand-marks-p) (object)
Package

cambl.

Methods
Writer Method: (setf get-thousand-marks-p) ((commodity commodity))

automatically generated writer method

Source

cambl.lisp.

Target Slot

thousand-marks-p.


5.2.5 Structures

Structure: balance
Package

cambl.

Source

cambl.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: amounts-map
Readers

get-amounts-map.

Writers

(setf get-amounts-map).

Structure: commodity-symbol
Package

cambl.

Source

cambl.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Type

string

Initform

""

Readers

commodity-symbol-name.

Writers

(setf commodity-symbol-name).

Slot: needs-quoting-p
Type

boolean

Readers

commodity-symbol-needs-quoting-p.

Writers

(setf commodity-symbol-needs-quoting-p).

Slot: prefixed-p
Type

boolean

Readers

commodity-symbol-prefixed-p.

Writers

(setf commodity-symbol-prefixed-p).

Slot: connected-p
Type

boolean

Readers

commodity-symbol-connected-p.

Writers

(setf commodity-symbol-connected-p).

Structure: pricing-entry
Package

cambl.

Source

cambl.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: moment
Readers

pricing-entry-moment.

Writers

(setf pricing-entry-moment).

Slot: price
Readers

pricing-entry-price.

Writers

(setf pricing-entry-price).


5.2.6 Classes

Class: commodity
Package

cambl.

Source

cambl.lisp.

Direct subclasses

annotated-commodity.

Direct methods
Direct slots
Slot: symbol
Package

common-lisp.

Initargs

:symbol

Readers

get-symbol.

Writers

(setf get-symbol).

Slot: description
Type

(or string null)

Initargs

:description

Readers

get-description.

Writers

(setf get-description).

Slot: comment
Type

(or string null)

Initargs

:comment

Readers

get-comment.

Writers

(setf get-comment).

Slot: thousand-marks-p
Type

boolean

Initargs

:thousand-marks-p

Readers

get-thousand-marks-p.

Writers

(setf get-thousand-marks-p).

Slot: european-style-p
Type

boolean

Initargs

:european-style-p

Readers

get-european-style-p.

Writers

(setf get-european-style-p).

Slot: no-market-price-p
Type

boolean

Initargs

:no-market-price-p

Readers

get-no-market-price-p.

Writers

(setf get-no-market-price-p).

Slot: builtin-p
Type

boolean

Initargs

:builtin-p

Readers

get-builtin-p.

Writers

(setf get-builtin-p).

Slot: display-precision
Type

cambl::fixnum+

Initform

0

Initargs

:display-precision

Readers

get-display-precision.

Writers

(setf get-display-precision).

Slot: price-history
Initargs

:price-history

Readers

get-price-history.

Writers

(setf get-price-history).

Slot: commodity-pool
Type

cambl:commodity-pool

Initargs

:commodity-pool

Readers

get-commodity-pool.

Writers

(setf get-commodity-pool).

Slot: qualified-name
Type

(or string null)

Initargs

:qualified-name

Readers

commodity-qualified-name.

Writers

(setf commodity-qualified-name).


5.2.7 Types

Type: fixnum+ ()
Package

cambl.

Source

cambl.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   I   M   N   P   R   S   T   V  
Index Entry  Section

(
(setf amount-commodity): Public ordinary functions
(setf amount-full-precision): Private ordinary functions
(setf amount-keep-precision-p): Public ordinary functions
(setf amount-quantity): Public ordinary functions
(setf annotation-date): Public ordinary functions
(setf annotation-price): Public ordinary functions
(setf annotation-tag): Public ordinary functions
(setf commodity-builtin-p): Public ordinary functions
(setf commodity-comment): Private ordinary functions
(setf commodity-description): Private ordinary functions
(setf commodity-european-style-p): Public ordinary functions
(setf commodity-no-market-price-p): Public ordinary functions
(setf commodity-pool): Public ordinary functions
(setf commodity-pool-by-name-map): Private ordinary functions
(setf commodity-pool-default-commodity): Private ordinary functions
(setf commodity-price-history): Public ordinary functions
(setf commodity-qualified-name): Public generic functions
(setf commodity-qualified-name): Public generic functions
(setf commodity-symbol): Private ordinary functions
(setf commodity-symbol-connected-p): Private ordinary functions
(setf commodity-symbol-name): Private ordinary functions
(setf commodity-symbol-needs-quoting-p): Private ordinary functions
(setf commodity-symbol-prefixed-p): Private ordinary functions
(setf commodity-thousand-marks-p): Public ordinary functions
(setf get-amounts-map): Public ordinary functions
(setf get-builtin-p): Private generic functions
(setf get-builtin-p): Private generic functions
(setf get-comment): Private generic functions
(setf get-comment): Private generic functions
(setf get-commodity-annotation): Private generic functions
(setf get-commodity-annotation): Private generic functions
(setf get-commodity-pool): Private generic functions
(setf get-commodity-pool): Private generic functions
(setf get-description): Private generic functions
(setf get-description): Private generic functions
(setf get-display-precision): Private generic functions
(setf get-display-precision): Private generic functions
(setf get-european-style-p): Private generic functions
(setf get-european-style-p): Private generic functions
(setf get-no-market-price-p): Private generic functions
(setf get-no-market-price-p): Private generic functions
(setf get-price-history): Private generic functions
(setf get-price-history): Private generic functions
(setf get-referent): Private generic functions
(setf get-referent): Private generic functions
(setf get-symbol): Private generic functions
(setf get-symbol): Private generic functions
(setf get-thousand-marks-p): Private generic functions
(setf get-thousand-marks-p): Private generic functions
(setf pricing-entry-moment): Private ordinary functions
(setf pricing-entry-price): Private ordinary functions

A
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add: Public generic functions
add-price: Private ordinary functions
amount: Public ordinary functions
amount*: Public ordinary functions
amount-commodity: Public ordinary functions
amount-full-precision: Private ordinary functions
amount-in-balance: Public ordinary functions
amount-keep-precision-p: Public ordinary functions
amount-p: Public ordinary functions
amount-precision: Public generic functions
amount-precision: Public generic functions
amount-precision: Public generic functions
amount-quantity: Public ordinary functions
annotate-commodity: Public generic functions
annotate-commodity: Public generic functions
annotate-commodity: Public generic functions
annotated-commodity-p: Public ordinary functions
annotation-date: Public ordinary functions
annotation-price: Public ordinary functions
annotation-tag: Public ordinary functions
apply-between-amounts: Private ordinary functions
apply-between-balances: Private ordinary functions
apply-to-balance: Private ordinary functions
apply-to-list: Public macros

B
balance: Private ordinary functions
balance-amounts: Public ordinary functions
balance-commodities: Public ordinary functions
balance-commodity-count: Public ordinary functions
balance-equal: Private ordinary functions
balance-first-amount: Public ordinary functions
balance-helper: Private ordinary functions
balance-p: Public ordinary functions

C
commodity-annotation: Public generic functions
commodity-annotation: Public generic functions
commodity-annotation: Public generic functions
commodity-annotation: Public generic functions
commodity-annotation-empty-p: Private generic functions
commodity-annotation-empty-p: Private generic functions
commodity-annotation-equal: Public generic functions
commodity-annotation-equal: Public generic functions
commodity-annotation-p: Private ordinary functions
commodity-builtin-p: Public ordinary functions
commodity-comment: Private ordinary functions
commodity-description: Private ordinary functions
commodity-equal: Public ordinary functions
commodity-equalp: Public ordinary functions
commodity-european-style-p: Public ordinary functions
commodity-lessp: Public ordinary functions
commodity-name: Public generic functions
commodity-name: Public generic functions
commodity-name: Public generic functions
commodity-name: Public generic functions
commodity-no-market-price-p: Public ordinary functions
commodity-pool: Public ordinary functions
commodity-pool-by-name-map: Private ordinary functions
commodity-pool-default-commodity: Private ordinary functions
commodity-pool-p: Private ordinary functions
commodity-price-history: Public ordinary functions
commodity-qualified-name: Public generic functions
commodity-qualified-name: Public generic functions
commodity-symbol: Private ordinary functions
commodity-symbol-connected-p: Private ordinary functions
commodity-symbol-name: Private ordinary functions
commodity-symbol-needs-quoting-p: Private ordinary functions
commodity-symbol-p: Private ordinary functions
commodity-symbol-prefixed-p: Private ordinary functions
commodity-thousand-marks-p: Public ordinary functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare: Public generic functions
compare*: Public generic functions
compare*: Public generic functions
compare*: Public generic functions
compare*: Public generic functions
compare*: Public generic functions
compare-amounts-visually: Public ordinary functions
copy-amount: Private ordinary functions
copy-balance: Private ordinary functions
copy-commodity-annotation: Private ordinary functions
copy-commodity-pool: Private ordinary functions
copy-commodity-symbol: Private ordinary functions
copy-pricing-entry: Private ordinary functions
create-annotated-commodity: Private ordinary functions
create-commodity: Private ordinary functions

D
define-commodity-accessor: Private macros
display-precision: Public generic functions
display-precision: Public generic functions
display-precision: Public generic functions
display-precision: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide: Public generic functions
divide-in-balance: Private ordinary functions

E
error-commodity: Private generic functions
error-commodity: Private generic functions
error-description: Private generic functions
error-description: Private generic functions
error-description: Private generic functions
error-operands: Private generic functions
error-operands: Private generic functions
exact-amount: Public ordinary functions
exchange-commodity: Public ordinary functions

F
find-annotated-commodity: Public ordinary functions
find-commodity: Public ordinary functions
find-nearest: Private ordinary functions
format-commodity-annotation: Private ordinary functions
format-value: Public generic functions
format-value: Public generic functions
format-value: Public generic functions
format-value: Public generic functions
Function, (setf amount-commodity): Public ordinary functions
Function, (setf amount-full-precision): Private ordinary functions
Function, (setf amount-keep-precision-p): Public ordinary functions
Function, (setf amount-quantity): Public ordinary functions
Function, (setf annotation-date): Public ordinary functions
Function, (setf annotation-price): Public ordinary functions
Function, (setf annotation-tag): Public ordinary functions
Function, (setf commodity-pool-by-name-map): Private ordinary functions
Function, (setf commodity-pool-default-commodity): Private ordinary functions
Function, (setf commodity-symbol-connected-p): Private ordinary functions
Function, (setf commodity-symbol-name): Private ordinary functions
Function, (setf commodity-symbol-needs-quoting-p): Private ordinary functions
Function, (setf commodity-symbol-prefixed-p): Private ordinary functions
Function, (setf get-amounts-map): Public ordinary functions
Function, (setf pricing-entry-moment): Private ordinary functions
Function, (setf pricing-entry-price): Private ordinary functions
Function, add-price: Private ordinary functions
Function, amount: Public ordinary functions
Function, amount*: Public ordinary functions
Function, amount-commodity: Public ordinary functions
Function, amount-full-precision: Private ordinary functions
Function, amount-in-balance: Public ordinary functions
Function, amount-keep-precision-p: Public ordinary functions
Function, amount-p: Public ordinary functions
Function, amount-quantity: Public ordinary functions
Function, annotated-commodity-p: Public ordinary functions
Function, annotation-date: Public ordinary functions
Function, annotation-price: Public ordinary functions
Function, annotation-tag: Public ordinary functions
Function, apply-between-amounts: Private ordinary functions
Function, apply-between-balances: Private ordinary functions
Function, apply-to-balance: Private ordinary functions
Function, balance: Private ordinary functions
Function, balance-amounts: Public ordinary functions
Function, balance-commodities: Public ordinary functions
Function, balance-commodity-count: Public ordinary functions
Function, balance-equal: Private ordinary functions
Function, balance-first-amount: Public ordinary functions
Function, balance-helper: Private ordinary functions
Function, balance-p: Public ordinary functions
Function, commodity-annotation-p: Private ordinary functions
Function, commodity-builtin-p: Public ordinary functions
Function, commodity-comment: Private ordinary functions
Function, commodity-description: Private ordinary functions
Function, commodity-equal: Public ordinary functions
Function, commodity-equalp: Public ordinary functions
Function, commodity-european-style-p: Public ordinary functions
Function, commodity-lessp: Public ordinary functions
Function, commodity-no-market-price-p: Public ordinary functions
Function, commodity-pool: Public ordinary functions
Function, commodity-pool-by-name-map: Private ordinary functions
Function, commodity-pool-default-commodity: Private ordinary functions
Function, commodity-pool-p: Private ordinary functions
Function, commodity-price-history: Public ordinary functions
Function, commodity-symbol: Private ordinary functions
Function, commodity-symbol-connected-p: Private ordinary functions
Function, commodity-symbol-name: Private ordinary functions
Function, commodity-symbol-needs-quoting-p: Private ordinary functions
Function, commodity-symbol-p: Private ordinary functions
Function, commodity-symbol-prefixed-p: Private ordinary functions
Function, commodity-thousand-marks-p: Public ordinary functions
Function, compare-amounts-visually: Public ordinary functions
Function, copy-amount: Private ordinary functions
Function, copy-balance: Private ordinary functions
Function, copy-commodity-annotation: Private ordinary functions
Function, copy-commodity-pool: Private ordinary functions
Function, copy-commodity-symbol: Private ordinary functions
Function, copy-pricing-entry: Private ordinary functions
Function, create-annotated-commodity: Private ordinary functions
Function, create-commodity: Private ordinary functions
Function, divide-in-balance: Private ordinary functions
Function, exact-amount: Public ordinary functions
Function, exchange-commodity: Public ordinary functions
Function, find-annotated-commodity: Public ordinary functions
Function, find-commodity: Public ordinary functions
Function, find-nearest: Private ordinary functions
Function, format-commodity-annotation: Private ordinary functions
Function, get-amounts-map: Public ordinary functions
Function, insert-if: Public ordinary functions
Function, make-amount: Private ordinary functions
Function, make-balance: Private ordinary functions
Function, make-commodity-annotation: Public ordinary functions
Function, make-commodity-pool: Public ordinary functions
Function, make-commodity-symbol: Private ordinary functions
Function, make-pricing-entry: Private ordinary functions
Function, make-qualified-name: Private ordinary functions
Function, mapcar-if: Public ordinary functions
Function, multiply-in-balance: Private ordinary functions
Function, parse-amount: Public ordinary functions
Function, parse-amount*: Public ordinary functions
Function, peek-char-in-line: Private ordinary functions
Function, pricing-entry-moment: Private ordinary functions
Function, pricing-entry-p: Private ordinary functions
Function, pricing-entry-price: Private ordinary functions
Function, print-amount: Private ordinary functions
Function, print-balance: Private ordinary functions
Function, print-value-to-string: Private ordinary functions
Function, read-amount: Public ordinary functions
Function, read-amount*: Public ordinary functions
Function, read-amount-quantity: Private ordinary functions
Function, read-commodity-annotation: Private ordinary functions
Function, read-commodity-symbol: Private ordinary functions
Function, read-exact-amount: Public ordinary functions
Function, read-until: Private ordinary functions
Function, remove-if: Public ordinary functions
Function, remove-price: Private ordinary functions
Function, reset-commodity-pool: Public ordinary functions
Function, sign: Public ordinary functions
Function, sign*: Public ordinary functions
Function, symbol-char-invalid-p: Private ordinary functions
Function, symbol-name-needs-quoting-p: Private ordinary functions
Function, timing-tests: Private ordinary functions
Function, value-greatereqp: Public ordinary functions
Function, value-greatereqp*: Public ordinary functions
Function, value-greaterp: Public ordinary functions
Function, value-greaterp*: Public ordinary functions
Function, value-lesseqp: Public ordinary functions
Function, value-lesseqp*: Public ordinary functions
Function, value-lessp: Public ordinary functions
Function, value-lessp*: Public ordinary functions
Function, value-maybe-round: Public ordinary functions
Function, value-round: Public ordinary functions
Function, value<: Public ordinary functions
Function, value<=: Public ordinary functions
Function, value>: Public ordinary functions
Function, value>=: Public ordinary functions
Function, valuep: Public ordinary functions
Function, verify-amounts: Private ordinary functions

G
Generic Function, (setf commodity-qualified-name): Public generic functions
Generic Function, (setf get-builtin-p): Private generic functions
Generic Function, (setf get-comment): Private generic functions
Generic Function, (setf get-commodity-annotation): Private generic functions
Generic Function, (setf get-commodity-pool): Private generic functions
Generic Function, (setf get-description): Private generic functions
Generic Function, (setf get-display-precision): Private generic functions
Generic Function, (setf get-european-style-p): Private generic functions
Generic Function, (setf get-no-market-price-p): Private generic functions
Generic Function, (setf get-price-history): Private generic functions
Generic Function, (setf get-referent): Private generic functions
Generic Function, (setf get-symbol): Private generic functions
Generic Function, (setf get-thousand-marks-p): Private generic functions
Generic Function, add: Public generic functions
Generic Function, amount-precision: Public generic functions
Generic Function, annotate-commodity: Public generic functions
Generic Function, commodity-annotation: Public generic functions
Generic Function, commodity-annotation-empty-p: Private generic functions
Generic Function, commodity-annotation-equal: Public generic functions
Generic Function, commodity-name: Public generic functions
Generic Function, commodity-qualified-name: Public generic functions
Generic Function, compare: Public generic functions
Generic Function, compare*: Public generic functions
Generic Function, display-precision: Public generic functions
Generic Function, divide: Public generic functions
Generic Function, error-commodity: Private generic functions
Generic Function, error-description: Private generic functions
Generic Function, error-operands: Private generic functions
Generic Function, format-value: Public generic functions
Generic Function, get-builtin-p: Private generic functions
Generic Function, get-comment: Private generic functions
Generic Function, get-commodity-annotation: Private generic functions
Generic Function, get-commodity-pool: Private generic functions
Generic Function, get-description: Private generic functions
Generic Function, get-display-precision: Private generic functions
Generic Function, get-european-style-p: Private generic functions
Generic Function, get-no-market-price-p: Private generic functions
Generic Function, get-price-history: Private generic functions
Generic Function, get-referent: Private generic functions
Generic Function, get-symbol: Private generic functions
Generic Function, get-thousand-marks-p: Private generic functions
Generic Function, market-value: Public generic functions
Generic Function, multiply: Public generic functions
Generic Function, negate: Public generic functions
Generic Function, print-value: Public generic functions
Generic Function, strip-annotations: Public generic functions
Generic Function, subtract: Public generic functions
Generic Function, value-abs: Public generic functions
Generic Function, value-equal: Public generic functions
Generic Function, value-equalp: Public generic functions
Generic Function, value-minusp: Public generic functions
Generic Function, value-minusp*: Public generic functions
Generic Function, value-not-equal: Public generic functions
Generic Function, value-not-equalp: Public generic functions
Generic Function, value-plusp: Public generic functions
Generic Function, value-plusp*: Public generic functions
Generic Function, value-zerop: Public generic functions
Generic Function, value-zerop*: Public generic functions
Generic Function, value/=: Public generic functions
Generic Function, value=: Public generic functions
get-amounts-map: Public ordinary functions
get-builtin-p: Private generic functions
get-builtin-p: Private generic functions
get-comment: Private generic functions
get-comment: Private generic functions
get-commodity-annotation: Private generic functions
get-commodity-annotation: Private generic functions
get-commodity-pool: Private generic functions
get-commodity-pool: Private generic functions
get-description: Private generic functions
get-description: Private generic functions
get-display-precision: Private generic functions
get-display-precision: Private generic functions
get-european-style-p: Private generic functions
get-european-style-p: Private generic functions
get-no-market-price-p: Private generic functions
get-no-market-price-p: Private generic functions
get-price-history: Private generic functions
get-price-history: Private generic functions
get-referent: Private generic functions
get-referent: Private generic functions
get-symbol: Private generic functions
get-symbol: Private generic functions
get-thousand-marks-p: Private generic functions
get-thousand-marks-p: Private generic functions

I
insert-if: Public ordinary functions

M
Macro, apply-to-list: Public macros
Macro, define-commodity-accessor: Private macros
Macro, pushend: Public macros
Macro, transform-balance: Private macros
make-amount: Private ordinary functions
make-balance: Private ordinary functions
make-commodity-annotation: Public ordinary functions
make-commodity-pool: Public ordinary functions
make-commodity-symbol: Private ordinary functions
make-pricing-entry: Private ordinary functions
make-qualified-name: Private ordinary functions
mapcar-if: Public ordinary functions
market-value: Public generic functions
market-value: Public generic functions
market-value: Public generic functions
market-value: Public generic functions
market-value: Public generic functions
market-value: Public generic functions
Method, (setf commodity-qualified-name): Public generic functions
Method, (setf get-builtin-p): Private generic functions
Method, (setf get-comment): Private generic functions
Method, (setf get-commodity-annotation): Private generic functions
Method, (setf get-commodity-pool): Private generic functions
Method, (setf get-description): Private generic functions
Method, (setf get-display-precision): Private generic functions
Method, (setf get-european-style-p): Private generic functions
Method, (setf get-no-market-price-p): Private generic functions
Method, (setf get-price-history): Private generic functions
Method, (setf get-referent): Private generic functions
Method, (setf get-symbol): Private generic functions
Method, (setf get-thousand-marks-p): Private generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, add: Public generic functions
Method, amount-precision: Public generic functions
Method, amount-precision: Public generic functions
Method, annotate-commodity: Public generic functions
Method, annotate-commodity: Public generic functions
Method, commodity-annotation: Public generic functions
Method, commodity-annotation: Public generic functions
Method, commodity-annotation: Public generic functions
Method, commodity-annotation-empty-p: Private generic functions
Method, commodity-annotation-equal: Public generic functions
Method, commodity-name: Public generic functions
Method, commodity-name: Public generic functions
Method, commodity-name: Public generic functions
Method, commodity-qualified-name: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare: Public generic functions
Method, compare*: Public generic functions
Method, compare*: Public generic functions
Method, compare*: Public generic functions
Method, compare*: Public generic functions
Method, display-precision: Public generic functions
Method, display-precision: Public generic functions
Method, display-precision: Public generic functions
Method, divide: Public generic functions
Method, divide: Public generic functions
Method, divide: Public generic functions
Method, divide: Public generic functions
Method, divide: Public generic functions
Method, divide: Public generic functions
Method, divide: Public generic functions
Method, error-commodity: Private generic functions
Method, error-description: Private generic functions
Method, error-description: Private generic functions
Method, error-operands: Private generic functions
Method, format-value: Public generic functions
Method, format-value: Public generic functions
Method, format-value: Public generic functions
Method, get-builtin-p: Private generic functions
Method, get-comment: Private generic functions
Method, get-commodity-annotation: Private generic functions
Method, get-commodity-pool: Private generic functions
Method, get-description: Private generic functions
Method, get-display-precision: Private generic functions
Method, get-european-style-p: Private generic functions
Method, get-no-market-price-p: Private generic functions
Method, get-price-history: Private generic functions
Method, get-referent: Private generic functions
Method, get-symbol: Private generic functions
Method, get-thousand-marks-p: Private generic functions
Method, market-value: Public generic functions
Method, market-value: Public generic functions
Method, market-value: Public generic functions
Method, market-value: Public generic functions
Method, market-value: Public generic functions
Method, multiply: Public generic functions
Method, multiply: Public generic functions
Method, multiply: Public generic functions
Method, multiply: Public generic functions
Method, multiply: Public generic functions
Method, multiply: Public generic functions
Method, multiply: Public generic functions
Method, negate: Public generic functions
Method, negate: Public generic functions
Method, negate: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-value: Public generic functions
Method, print-value: Public generic functions
Method, print-value: Public generic functions
Method, print-value: Public generic functions
Method, strip-annotations: Public generic functions
Method, strip-annotations: Public generic functions
Method, strip-annotations: Public generic functions
Method, strip-annotations: Public generic functions
Method, strip-annotations: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, subtract: Public generic functions
Method, value-abs: Public generic functions
Method, value-abs: Public generic functions
Method, value-abs: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equal: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-equalp: Public generic functions
Method, value-minusp: Public generic functions
Method, value-minusp: Public generic functions
Method, value-minusp: Public generic functions
Method, value-minusp*: Public generic functions
Method, value-minusp*: Public generic functions
Method, value-minusp*: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equal: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-not-equalp: Public generic functions
Method, value-plusp: Public generic functions
Method, value-plusp: Public generic functions
Method, value-plusp: Public generic functions
Method, value-plusp*: Public generic functions
Method, value-plusp*: Public generic functions
Method, value-plusp*: Public generic functions
Method, value-zerop: Public generic functions
Method, value-zerop: Public generic functions
Method, value-zerop: Public generic functions
Method, value-zerop*: Public generic functions
Method, value-zerop*: Public generic functions
Method, value-zerop*: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value/=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
Method, value=: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply: Public generic functions
multiply-in-balance: Private ordinary functions

N
negate: Public generic functions
negate: Public generic functions
negate: Public generic functions
negate: Public generic functions

P
parse-amount: Public ordinary functions
parse-amount*: Public ordinary functions
peek-char-in-line: Private ordinary functions
pricing-entry-moment: Private ordinary functions
pricing-entry-p: Private ordinary functions
pricing-entry-price: Private ordinary functions
print-amount: Private ordinary functions
print-balance: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-value: Public generic functions
print-value: Public generic functions
print-value: Public generic functions
print-value: Public generic functions
print-value: Public generic functions
print-value-to-string: Private ordinary functions
pushend: Public macros

R
read-amount: Public ordinary functions
read-amount*: Public ordinary functions
read-amount-quantity: Private ordinary functions
read-commodity-annotation: Private ordinary functions
read-commodity-symbol: Private ordinary functions
read-exact-amount: Public ordinary functions
read-until: Private ordinary functions
remove-if: Public ordinary functions
remove-price: Private ordinary functions
reset-commodity-pool: Public ordinary functions

S
Setf Expander, (setf commodity-builtin-p): Public ordinary functions
Setf Expander, (setf commodity-comment): Private ordinary functions
Setf Expander, (setf commodity-description): Private ordinary functions
Setf Expander, (setf commodity-european-style-p): Public ordinary functions
Setf Expander, (setf commodity-no-market-price-p): Public ordinary functions
Setf Expander, (setf commodity-pool): Public ordinary functions
Setf Expander, (setf commodity-price-history): Public ordinary functions
Setf Expander, (setf commodity-symbol): Private ordinary functions
Setf Expander, (setf commodity-thousand-marks-p): Public ordinary functions
sign: Public ordinary functions
sign*: Public ordinary functions
strip-annotations: Public generic functions
strip-annotations: Public generic functions
strip-annotations: Public generic functions
strip-annotations: Public generic functions
strip-annotations: Public generic functions
strip-annotations: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
subtract: Public generic functions
symbol-char-invalid-p: Private ordinary functions
symbol-name-needs-quoting-p: Private ordinary functions

T
timing-tests: Private ordinary functions
transform-balance: Private macros

V
value-abs: Public generic functions
value-abs: Public generic functions
value-abs: Public generic functions
value-abs: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equal: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-equalp: Public generic functions
value-greatereqp: Public ordinary functions
value-greatereqp*: Public ordinary functions
value-greaterp: Public ordinary functions
value-greaterp*: Public ordinary functions
value-lesseqp: Public ordinary functions
value-lesseqp*: Public ordinary functions
value-lessp: Public ordinary functions
value-lessp*: Public ordinary functions
value-maybe-round: Public ordinary functions
value-minusp: Public generic functions
value-minusp: Public generic functions
value-minusp: Public generic functions
value-minusp: Public generic functions
value-minusp*: Public generic functions
value-minusp*: Public generic functions
value-minusp*: Public generic functions
value-minusp*: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equal: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-not-equalp: Public generic functions
value-plusp: Public generic functions
value-plusp: Public generic functions
value-plusp: Public generic functions
value-plusp: Public generic functions
value-plusp*: Public generic functions
value-plusp*: Public generic functions
value-plusp*: Public generic functions
value-plusp*: Public generic functions
value-round: Public ordinary functions
value-zerop: Public generic functions
value-zerop: Public generic functions
value-zerop: Public generic functions
value-zerop: Public generic functions
value-zerop*: Public generic functions
value-zerop*: Public generic functions
value-zerop*: Public generic functions
value-zerop*: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value/=: Public generic functions
value<: Public ordinary functions
value<=: Public ordinary functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value=: Public generic functions
value>: Public ordinary functions
value>=: Public ordinary functions
valuep: Public ordinary functions
verify-amounts: Private ordinary functions


A.3 Variables

Jump to:   *  
A   B   C   D   E   F   K   M   N   O   P   Q   R   S   T  
Index Entry  Section

*
*default-commodity-pool*: Public special variables
*default-display-precision*: Public special variables
*extra-precision*: Public special variables
*invalid-symbol-chars*: Private special variables

A
amounts-map: Private structures
annotation: Public classes

B
builtin-p: Private classes
by-name-map: Public structures

C
comment: Private classes
commodity: Public conditions
commodity: Public structures
commodity-pool: Private classes
connected-p: Private structures

D
date: Public structures
default-commodity: Public structures
description: Public conditions
description: Public conditions
description: Private classes
display-precision: Private classes

E
european-style-p: Private classes

F
full-precision: Public structures

K
keep-precision-p: Public structures

M
moment: Private structures

N
name: Private structures
needs-quoting-p: Private structures
no-market-price-p: Private classes

O
operands: Public conditions

P
prefixed-p: Private structures
price: Public structures
price: Private structures
price-history: Private classes

Q
qualified-name: Private classes
quantity: Public structures

R
referent: Public classes

S
Slot, amounts-map: Private structures
Slot, annotation: Public classes
Slot, builtin-p: Private classes
Slot, by-name-map: Public structures
Slot, comment: Private classes
Slot, commodity: Public conditions
Slot, commodity: Public structures
Slot, commodity-pool: Private classes
Slot, connected-p: Private structures
Slot, date: Public structures
Slot, default-commodity: Public structures
Slot, description: Public conditions
Slot, description: Public conditions
Slot, description: Private classes
Slot, display-precision: Private classes
Slot, european-style-p: Private classes
Slot, full-precision: Public structures
Slot, keep-precision-p: Public structures
Slot, moment: Private structures
Slot, name: Private structures
Slot, needs-quoting-p: Private structures
Slot, no-market-price-p: Private classes
Slot, operands: Public conditions
Slot, prefixed-p: Private structures
Slot, price: Public structures
Slot, price: Private structures
Slot, price-history: Private classes
Slot, qualified-name: Private classes
Slot, quantity: Public structures
Slot, referent: Public classes
Slot, symbol: Private classes
Slot, tag: Public structures
Slot, thousand-marks-p: Private classes
Special Variable, *default-commodity-pool*: Public special variables
Special Variable, *default-display-precision*: Public special variables
Special Variable, *extra-precision*: Public special variables
Special Variable, *invalid-symbol-chars*: Private special variables
symbol: Private classes

T
tag: Public structures
thousand-marks-p: Private classes


A.4 Data types

Jump to:   A   B   C   F   P   S   T   V  
Index Entry  Section

A
amount: Public structures
amount-error: Public conditions
annotated-commodity: Public classes

B
balance: Private structures

C
cambl: The cambl system
cambl: The cambl package
cambl.asd: The cambl/cambl․asd file
cambl.lisp: The cambl/cambl․lisp file
Class, annotated-commodity: Public classes
Class, commodity: Private classes
commodity: Private classes
commodity-annotation: Public structures
commodity-error: Public conditions
commodity-pool: Public structures
commodity-symbol: Private structures
Condition, amount-error: Public conditions
Condition, commodity-error: Public conditions

F
File, cambl.asd: The cambl/cambl․asd file
File, cambl.lisp: The cambl/cambl․lisp file
File, fprog.asd: The fprog/fprog․asd file
File, fprog.lisp: The fprog/fprog․lisp file
fixnum+: Private types
fprog: The fprog system
fprog: The fprog package
fprog.asd: The fprog/fprog․asd file
fprog.lisp: The fprog/fprog․lisp file

P
Package, cambl: The cambl package
Package, fprog: The fprog package
pricing-entry: Private structures

S
Structure, amount: Public structures
Structure, balance: Private structures
Structure, commodity-annotation: Public structures
Structure, commodity-pool: Public structures
Structure, commodity-symbol: Private structures
Structure, pricing-entry: Private structures
System, cambl: The cambl system
System, fprog: The fprog system

T
Type, fixnum+: Private types
Type, value: Public types

V
value: Public types