The cambl Reference Manual

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

• *default-commodity-pool* (special variable).
• *default-display-precision* (special variable).
• *extra-precision* (special variable).
• add (generic function).
• amount (function).
• amount (structure).
• amount* (function).
• amount-commodity (reader).
• (setf amount-commodity) (writer).
• amount-error (condition).
• amount-in-balance (function).
• amount-keep-precision-p (reader).
• (setf amount-keep-precision-p) (writer).
• amount-p (function).
• amount-precision (generic function).
• amount-quantity (reader).
• (setf amount-quantity) (writer).
• annotate-commodity (generic function).
• annotated-commodity (class).
• annotated-commodity-p (function).
• annotation-date (reader).
• (setf annotation-date) (writer).
• annotation-price (reader).
• (setf annotation-price) (writer).
• annotation-tag (reader).
• (setf annotation-tag) (writer).
• balance-amounts (function).
• balance-commodities (function).
• balance-commodity-count (function).
• balance-first-amount (function).
• balance-p (function).
• commodity-annotation (generic function).
• commodity-annotation (structure).
• commodity-annotation-equal (generic function).
• (setf commodity-builtin-p) (setf expander).
• commodity-builtin-p (function).
• commodity-equal (function).
• commodity-equalp (function).
• commodity-error (condition).
• (setf commodity-european-style-p) (setf expander).
• commodity-european-style-p (function).
• commodity-lessp (function).
• commodity-name (generic function).
• (setf commodity-no-market-price-p) (setf expander).
• commodity-no-market-price-p (function).
• (setf commodity-pool) (setf expander).
• commodity-pool (function).
• commodity-pool (structure).
• (setf commodity-price-history) (setf expander).
• commodity-price-history (function).
• commodity-qualified-name (reader method).
• (setf commodity-qualified-name) (writer method).
• (setf commodity-thousand-marks-p) (setf expander).
• commodity-thousand-marks-p (function).
• compare (generic function).
• compare* (generic function).
• compare-amounts-visually (function).
• display-precision (generic function).
• divide (generic function).
• exact-amount (function).
• exchange-commodity (function).
• find-annotated-commodity (function).
• find-commodity (function).
• format-value (generic function).
• get-amounts-map (reader).
• (setf get-amounts-map) (writer).
• make-commodity-annotation (function).
• make-commodity-pool (function).
• market-value (generic function).
• multiply (generic function).
• negate (generic function).
• parse-amount (function).
• parse-amount* (function).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).
• print-value (generic function).
• pushend (macro).
• read-amount (function).
• read-amount* (function).
• read-exact-amount (function).
• reset-commodity-pool (function).
• sign (function).
• sign* (function).
• strip-annotations (generic function).
• subtract (generic function).
• value (type).
• value-abs (generic function).
• value-equal (generic function).
• value-equalp (generic function).
• value-greatereqp (function).
• value-greatereqp* (function).
• value-greaterp (function).
• value-greaterp* (function).
• value-lesseqp (function).
• value-lesseqp* (function).
• value-lessp (function).
• value-lessp* (function).
• value-maybe-round (function).
• value-minusp (generic function).
• value-minusp* (generic function).
• value-not-equal (generic function).
• value-not-equalp (generic function).
• value-plusp (generic function).
• value-plusp* (generic function).
• value-round (function).
• value-zerop (generic function).
• value-zerop* (generic function).
• value/= (generic function).
• value< (function).
• value<= (function).
• value= (generic function).
• value> (function).
• value>= (function).
• valuep (function).

Internals

• *invalid-symbol-chars* (special variable).
• add-price (function).
• amount-full-precision (reader).
• (setf amount-full-precision) (writer).
• apply-between-amounts (function).
• apply-between-balances (function).
• apply-to-balance (function).
• balance (function).
• balance (structure).
• balance-equal (function).
• balance-helper (function).
• commodity (class).
• commodity-annotation-empty-p (generic function).
• commodity-annotation-p (function).
• (setf commodity-comment) (setf expander).
• commodity-comment (function).
• (setf commodity-description) (setf expander).
• commodity-description (function).
• commodity-pool-by-name-map (reader).
• (setf commodity-pool-by-name-map) (writer).
• commodity-pool-default-commodity (reader).
• (setf commodity-pool-default-commodity) (writer).
• commodity-pool-p (function).
• (setf commodity-symbol) (setf expander).
• commodity-symbol (function).
• commodity-symbol (structure).
• commodity-symbol-connected-p (reader).
• (setf commodity-symbol-connected-p) (writer).
• commodity-symbol-name (reader).
• (setf commodity-symbol-name) (writer).
• commodity-symbol-needs-quoting-p (reader).
• (setf commodity-symbol-needs-quoting-p) (writer).
• commodity-symbol-p (function).
• commodity-symbol-prefixed-p (reader).
• (setf commodity-symbol-prefixed-p) (writer).
• copy-amount (function).
• copy-balance (function).
• copy-commodity-annotation (function).
• copy-commodity-pool (function).
• copy-commodity-symbol (function).
• copy-pricing-entry (function).
• create-annotated-commodity (function).
• create-commodity (function).
• define-commodity-accessor (macro).
• divide-in-balance (function).
• error-commodity (reader method).
• error-description (reader method).
• error-description (reader method).
• error-operands (reader method).
• find-nearest (function).
• fixnum+ (type).
• format-commodity-annotation (function).
• get-builtin-p (reader method).
• (setf get-builtin-p) (writer method).
• get-comment (reader method).
• (setf get-comment) (writer method).
• get-commodity-annotation (reader method).
• (setf get-commodity-annotation) (writer method).
• get-commodity-pool (reader method).
• (setf get-commodity-pool) (writer method).
• get-description (reader method).
• (setf get-description) (writer method).
• get-display-precision (reader method).
• (setf get-display-precision) (writer method).
• get-european-style-p (reader method).
• (setf get-european-style-p) (writer method).
• get-no-market-price-p (reader method).
• (setf get-no-market-price-p) (writer method).
• get-price-history (reader method).
• (setf get-price-history) (writer method).
• get-referent (reader method).
• (setf get-referent) (writer method).
• get-symbol (reader method).
• (setf get-symbol) (writer method).
• get-thousand-marks-p (reader method).
• (setf get-thousand-marks-p) (writer method).
• make-amount (function).
• make-balance (function).
• make-commodity-symbol (function).
• make-pricing-entry (function).
• make-qualified-name (function).
• multiply-in-balance (function).
• peek-char-in-line (function).
• pricing-entry (structure).
• pricing-entry-moment (reader).
• (setf pricing-entry-moment) (writer).
• pricing-entry-p (function).
• pricing-entry-price (reader).
• (setf pricing-entry-price) (writer).
• print-amount (function).
• print-balance (function).
• print-value-to-string (function).
• read-amount-quantity (function).
• read-commodity-annotation (function).
• read-commodity-symbol (function).
• read-until (function).
• remove-price (function).
• symbol-char-invalid-p (function).
• symbol-name-needs-quoting-p (function).
• transform-balance (macro).
• verify-amounts (function).

---

3.1.4 fprog/fprog.lisp

Source

fprog.asd.

Parent Component

fprog (system).

Packages

fprog.

Public Interface

• apply-to-list (macro).
• insert-if (function).
• mapcar-if (function).
• remove-if (function).

Internals

timing-tests (function).

---

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

• error-description.
• error-operands.

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

• error-commodity.
• error-description.

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

• add.
• add.
• add.
• add.
• add.
• amount-precision.
• annotate-commodity.
• commodity-annotation.
• commodity-name.
• compare.
• compare.
• compare.
• compare*.
• compare*.
• compare*.
• display-precision.
• divide.
• divide.
• divide.
• divide.
• format-value.
• market-value.
• multiply.
• multiply.
• multiply.
• multiply.
• negate.
• print-object.
• print-value.
• strip-annotations.
• subtract.
• subtract.
• subtract.
• subtract.
• subtract.
• value-abs.
• value-equal.
• value-equal.
• value-equal.
• value-equal.
• value-equal.
• value-equalp.
• value-equalp.
• value-equalp.
• value-equalp.
• value-equalp.
• value-minusp.
• value-minusp*.
• value-not-equal.
• value-not-equal.
• value-not-equal.
• value-not-equal.
• value-not-equal.
• value-not-equalp.
• value-not-equalp.
• value-not-equalp.
• value-not-equalp.
• value-not-equalp.
• value-plusp.
• value-plusp*.
• value-zerop.
• value-zerop*.
• value/=.
• value/=.
• value/=.
• value/=.
• value/=.
• value=.
• value=.
• value=.
• value=.
• value=.

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

• annotate-commodity.
• annotate-commodity.
• commodity-annotation-empty-p.
• commodity-annotation-equal.

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

• commodity-annotation.
• display-precision.
• (setf get-commodity-annotation).
• get-commodity-annotation.
• (setf get-referent).
• get-referent.
• market-value.
• print-object.
• strip-annotations.

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.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.

---