The cambl Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cambl Reference Manual

This is the cambl Reference Manual, version 4.0.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 10:51:34 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

#+TITLE: CAMBL

*Commoditized Amounts and Balances*\\

This library provides a convenient facility for working with
commoditized values. It does not allow compound units -- and so is not
suited for scientific operations -- but does work rather nicely for
the purpose of financial calculations.

The primary entry point to using this library is the creation of
/VALUES/, which may be of many different types. These /VALUES/ are
then used as arguments to a set of basic mathematical /OPERATIONS/,
which also yield /VALUES/. However, the type of the result may not be
the same type as either of the operands.

For example, let's say you want to create a figure representing 10 US
dollars. You then add an /INTEGER/ to this amount, the number 200. The
result of such an operation will be an amalgam of the two units
involved: Dollars, and No-units. This dual-commodity value is
represented as a /BALANCE/ object, whose printed form shows each
commodity amount on its own line. For example:

#+BEGIN_SRC lisp
(let ((value (cambl:amount "$100.00")))
  (princ (cambl:format-value (cambl:add value 200))))
 => 200
    $100.00
#+END_SRC

This library aims to provide convenient access to commoditized math;
that is: math involving commodity units. Unlike scientific units,
there is no concept of "compound" units. If you divide 1kg by 1m, you
do not get "1 kg/m", but "1 kg" (the unit of the second operand is
ignored for multiplication and division). The intended use of this
library is in situations such as computing financial transactions.

* Amounts

There are just a few main entry points to the *CAMBL* library for
dealing with amounts (which is mainly how you'll use it). Here is
a quick list, following by a description in the context of a REPL
session. Note that where the name contains value, it will work for
integers, amounts and balances. If it contains amount or balance, it
only operates on entities of that type.

|-------------------+----------------------------------------------------|
| Function          | Description                                        |
|-------------------+----------------------------------------------------|
| amount[*]         | create an amount from a string                     |
|-------------------+----------------------------------------------------|
| exact-amount      | create an amount from a string which overrides     |
|                   | its commodity's display precision; this feature    |
|                   | "sticks" through any math operations               |
|-------------------+----------------------------------------------------|
| parse-amount[*]   | parse an amount from a string (alias for 'amount') |
|-------------------+----------------------------------------------------|
| read-amount[*]    | read an amount from a stream                       |
|-------------------+----------------------------------------------------|
| read-exact-amount | read an exact amount from a stream                 |
|-------------------+----------------------------------------------------|
| format-value      | format a value to a string                         |
|-------------------+----------------------------------------------------|
| print-value       | print a value to a stream                          |
|-------------------+----------------------------------------------------|
| add               | perform math using values; the values are          |
| subtract          | changed as necessary to preserve information       |
| multiply          | (adding two amounts may result in a                |
| divide            | balance).                                          |
|-------------------+----------------------------------------------------|
| value-zerop       | would the value display as zero?                   |
|-------------------+----------------------------------------------------|
| value-zerop*      | is the value truly zero?                           |
|-------------------+----------------------------------------------------|
| value-minusp      | would the amount display as a negative amount?     |
|-------------------+----------------------------------------------------|
| value-minusp*     | is the amount truly negative?                      |
|-------------------+----------------------------------------------------|
| value-plusp       | would it display as an amount greater than zero?   |
|-------------------+----------------------------------------------------|
| value-plusp*      | is it truly greater than zero?                     |
|-------------------+----------------------------------------------------|
| value=            | compare two values                                 |
| value/=           |                                                    |
|-------------------+----------------------------------------------------|
| value<            | compare values (not meaningful for all values,     |
| value<=           | such as balances)                                  |
| value>            |                                                    |
| value>=           |                                                    |
|-------------------+----------------------------------------------------|
| value-equal       | compare two values for exact match                 |
|-------------------+----------------------------------------------------|
| value-equalp      | compare two values only after rounding to what     |
|                   | would be shown to the user (approximate match)     |
|                   | -- this is the same as value=                      |
|-------------------+----------------------------------------------------|
| value-not-equal   | compare if two values for not an exact match       |
|-------------------+----------------------------------------------------|
| value-not-equalp  | compare two values after commodity rounding        |
|-------------------+----------------------------------------------------|
| value-lessp       | same as value<                                     |
|-------------------+----------------------------------------------------|
| value-lessp*      | compare if a < b exactly, with full precision      |
|-------------------+----------------------------------------------------|
| value-lesseqp     | same as value<=                                    |
|-------------------+----------------------------------------------------|
| value-lesseqp*    | exact version of value<=                           |
|-------------------+----------------------------------------------------|
| value-greaterp    | same as value>                                     |
|-------------------+----------------------------------------------------|
| value-greaterp*   | exact version of value>                            |
|-------------------+----------------------------------------------------|
| value-greatereqp  | same as value>=                                    |
|-------------------+----------------------------------------------------|
| value-greatereqp* | exact version of value>=                           |
|-------------------+----------------------------------------------------|
| amount-precision  | return the internal precision of an amount         |
|-------------------+----------------------------------------------------|
| display-precision | return the "display" precision for an amount       |
|                   | or a commodity                                     |
|-------------------+----------------------------------------------------|

* Example Session

Interacting with *CAMBL* begins with creating an amount. This is done
most easily from a string, but it can also be read from a stream:

#+BEGIN_SRC lisp
(cambl:amount "$100.00")
 => #

(with-input-from-string (in "$100.00")
  (cambl:read-amount in))
 => #
#+END_SRC

When you parse an amount using one of these two functions, *CAMBL*
creates a /COMMODITY/ class for you, whose symbol name is "$". This
class remembers details about how you used the commodity, such as the
input precision and the format of the commodity symbol. Some of these
details can be inspected by looking at the amount's commodity
directly:

#+BEGIN_SRC lisp
(cambl:amount-commodity (cambl:amount "$100.00"))
 => #
#+END_SRC

Here you can see that the commodity for $100.00 is $, and it knows
that the commodity should be prefixed to the amount, and that it gets
connected to the amount. This commodity was used without any "thousand
marks" (i.e. $1000.00 vs $1,000.00), and it has a maximum display
precision of TWO observed so far. If we print such an amount, we'll
see the same style as was input:

#+BEGIN_SRC lisp
(cambl:format-value (cambl:amount "$100.00"))
 => "$100.00"
(cambl:print-value (cambl:amount "$100.00"))
 => NIL
  $100.00
#+END_SRC

*CAMBL* observed how you used the "$" commodity, and now reports back
all dollar figures after the same fashion. Even though there are no
cents in the amounts above, *CAMBL* will still record a full two
digits of precision (this becomes important during division, to guard
against fractional losses during repeated rounding).

#+BEGIN_SRC lisp
(cambl:amount-precision (cambl:amount "$100.00"))
 => 2
#+END_SRC

*CAMBL* remembers the greatest precision it has seen thus far, but
never records a lesser precision. So if you parse $100.00 and then
$100, both values will be printed as $100.00.

There are three functions for creating amounts, but they have some
subtle differences where precision is concerned. They are: ~amount~,
~amount*~, and ~exact-amount~. Here are the differences:

#+BEGIN_SRC lisp
(cambl:amount "$100.00")
 => #
#+END_SRC

 - amount has an internal precision of 2
 - commodity $ has a display precision of 2 (if no other
   amount using a higher precision was observed so far)
 - when printing, amount uses the commodity's precision

#+BEGIN_SRC lisp
(cambl:format-value *)
 => "$100.00"
(cambl:format-value ** :full-precision-p t)
 => "$100.00"
#+END_SRC

#+BEGIN_SRC lisp
(cambl:amount* "$100.0000")
 => #
#+END_SRC

 - amount has an internal precision of 4
 - commodity $ still has a display precision of 2 (from above)
 - when printing, amount uses the commodity's precision

#+BEGIN_SRC lisp
(cambl:format-value *)
 => "$100.00"
(cambl:format-value ** :full-precision-p t)
 => "$100.0000"
#+END_SRC

#+BEGIN_SRC lisp
(cambl:exact-amount "$100.0000")
 => #
#+END_SRC

 - amount has an internal precision of 4
 - commodity $ still has a display precision of 2 (from above)
 - when printing, amount uses its internal precision

#+BEGIN_SRC lisp
(cambl:format-value *)
 => "$100.0000"
(cambl:format-value ** :full-precision-p t)
 => "$100.0000"
#+END_SRC

There are similar variants for the stream reading functions:

  - ~read-amount~
  - ~read-amount*~
  - ~read-exact-amount~

Internally, an amount's quantity is stored as a rational number, and
therefore has a perfect precision. The internal precision field of an
amount tries to keep track of the number of decimals to display when
printing a value with the ~FULL-PRECISION-P~ option.

By default, uncommoditized amounts (which are in fact just rational
numbers), are displayed with a precision of 3. This can be changed by
setting ~CAMBL:*DEFAULT-DISPLAY-PRECISION*~. When they are used in
math operations, their considered internal precision to compute the
result's internal precision is at most ~CAMBL:*EXTRA-PRECISION*~
(which is 6 by default).

_NOTE:_ The ~KEEP-PRECISION-P~ property of an amount carries through
any math operations involving that amount, so that the final result is
always displayed using its own internal percision.

The point of all this is that amounts are displayed as the user
expects them to be, but internally never lose information. In fact, if
you divide two high internal precision amounts together, you'll get
a new amount with a very high internal precision, but which still
displays as expected:

#+BEGIN_SRC lisp
(setf *tmp* (cambl:divide (cambl:amount "$100.00")
                          (cambl:amount "50000000")))

(cambl:format-value *tmp* :full-precision-p t)
 => "$0.0000020000000000"
(cambl:format-value *tmp*)
 => "$0.00"
#+END_SRC

You'll notice here that the amount displayed is not
$0.00000200000000002. This is because *CAMBL* does not try to capture
every digit resulting from a division; rather, it keeps six more
digits of precision than is strictly necessary so that even after
millions of calculations, not a penny is lost. If you find this is not
enough slack for your calculations, you can set
~CAMBL:*EXTRA-PRECISION*~ to a higher or lower value.

* Commodities

*CAMBL* offers several methods for accessing the commodity information
relating to amounts:

|--------------------------+---------------------------------------------|
| Function                 | Description                                 |
|--------------------------+---------------------------------------------|
| amount-commodity         | the COMMODITY referenced by an amount       |
|--------------------------+---------------------------------------------|
| display-precision        | display precision of an AMOUNT or COMMODITY |
|--------------------------+---------------------------------------------|
| commodity-qualified-name | the name used print a COMMODITY             |
|--------------------------+---------------------------------------------|


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Next: , Previous: , Up: Systems   [Contents][Index]

2.1 cambl

Maintainer

Christophe Junke <junke.christophe@gmail.com>

Author

Johh Wiegley <jwiegley@gmail.com>

License

BSD-3

Description

A library for working with financial amounts involving multiple commodities.

Version

4.0.0

Dependencies
Source

cambl.asd (file)

Component

cambl.lisp (file)


Previous: , Up: Systems   [Contents][Index]

2.2 fprog

Maintainer

Christophe Junke <junke.christophe@gmail.com>

Author

Johh Wiegley <jwiegley@gmail.com>

License

BSD-3

Description

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

Version

1.0.0

Source

fprog.asd (file)

Component

fprog.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 cambl.asd

Location

cambl.asd

Systems

cambl (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 fprog.asd

Location

fprog.asd

Systems

fprog (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 cambl/cambl.lisp

Parent

cambl (system)

Location

cambl.lisp

Packages

cambl

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.4 fprog/fprog.lisp

Parent

fprog (system)

Location

fprog.lisp

Packages

fprog

Exported Definitions
Internal Definitions

timing-tests (function)


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 cambl

Source

cambl.lisp (file)

Use List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.2 fprog

Source

fprog.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

timing-tests (function)


Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *default-commodity-pool*
Package

cambl

Source

cambl.lisp (file)

Special Variable: *default-display-precision*
Package

cambl

Source

cambl.lisp (file)

Special Variable: *extra-precision*
Package

cambl

Source

cambl.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

Macro: pushend ITEM THE-LIST &optional FINAL-CONS
Package

cambl

Source

cambl.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: amount STRING &key POOL
Package

cambl

Source

cambl.lisp (file)

Function: amount* STRING &key POOL
Package

cambl

Source

cambl.lisp (file)

Function: amount-commodity INSTANCE
Function: (setf amount-commodity) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: amount-in-balance BALANCE COMMODITY
Package

cambl

Source

cambl.lisp (file)

Function: amount-keep-precision-p INSTANCE
Function: (setf amount-keep-precision-p) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: amount-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: amount-quantity INSTANCE
Function: (setf amount-quantity) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: annotated-commodity-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: annotation-date INSTANCE
Function: (setf annotation-date) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: annotation-price INSTANCE
Function: (setf annotation-price) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: annotation-tag INSTANCE
Function: (setf annotation-tag) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: balance-amounts BALANCE
Package

cambl

Source

cambl.lisp (file)

Function: balance-commodities BALANCE
Package

cambl

Source

cambl.lisp (file)

Function: balance-commodity-count BALANCE
Package

cambl

Source

cambl.lisp (file)

Function: balance-first-amount BALANCE
Package

cambl

Source

cambl.lisp (file)

Function: balance-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: commodity-builtin-p COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-builtin-p) (setf expander)

Setf Expander: (setf commodity-builtin-p) COMM
Package

cambl

Source

cambl.lisp (file)

Reader

commodity-builtin-p (function)

Function: commodity-equal A B

Two commodities are EQUAL if they are the same object.

Package

cambl

Source

cambl.lisp (file)

Function: commodity-equalp A B
Package

cambl

Source

cambl.lisp (file)

Function: commodity-european-style-p COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-european-style-p) (setf expander)

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

cambl

Source

cambl.lisp (file)

Reader

commodity-european-style-p (function)

Function: commodity-lessp LEFT RIGHT

Return T if commodity LEFT should be sorted before RIGHT.

Package

cambl

Source

cambl.lisp (file)

Function: commodity-no-market-price-p COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-no-market-price-p) (setf expander)

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

cambl

Source

cambl.lisp (file)

Reader

commodity-no-market-price-p (function)

Function: commodity-pool COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-pool) (setf expander)

Setf Expander: (setf commodity-pool) COMM
Package

cambl

Source

cambl.lisp (file)

Reader

commodity-pool (function)

Function: commodity-price-history COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-price-history) (setf expander)

Setf Expander: (setf commodity-price-history) COMM
Package

cambl

Source

cambl.lisp (file)

Reader

commodity-price-history (function)

Function: commodity-thousand-marks-p COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-thousand-marks-p) (setf expander)

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

cambl

Source

cambl.lisp (file)

Reader

commodity-thousand-marks-p (function)

Function: compare-amounts-visually LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: exact-amount STRING &key POOL
Package

cambl

Source

cambl.lisp (file)

Function: exchange-commodity AMOUNT &key TOTAL-COST PER-UNIT-COST MOMENT TAG
Package

cambl

Source

cambl.lisp (file)

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 (file)

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 (file)

Function: get-amounts-map INSTANCE
Function: (setf get-amounts-map) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: insert-if PREDICATE FUNCTION LIST
Package

fprog

Source

fprog.lisp (file)

Function: make-commodity-annotation &key (PRICE PRICE) (DATE DATE) (TAG TAG)
Package

cambl

Source

cambl.lisp (file)

Function: make-commodity-pool &key (BY-NAME-MAP BY-NAME-MAP) (DEFAULT-COMMODITY DEFAULT-COMMODITY)
Package

cambl

Source

cambl.lisp (file)

Function: mapcar-if PREDICATE FUNCTION LIST
Package

fprog

Source

fprog.lisp (file)

Function: parse-amount &rest ARGS
Package

cambl

Source

cambl.lisp (file)

Function: parse-amount* &rest ARGS
Package

cambl

Source

cambl.lisp (file)

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 (file)

Function: read-amount* IN &key POOL
Package

cambl

Source

cambl.lisp (file)

Function: read-exact-amount IN &key POOL
Package

cambl

Source

cambl.lisp (file)

Function: remove-if PREDICATE LIST
Package

fprog

Source

fprog.lisp (file)

Function: reset-commodity-pool &optional POOL
Package

cambl

Source

cambl.lisp (file)

Function: sign AMOUNT

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

Package

cambl

Source

cambl.lisp (file)

Function: sign* AMOUNT

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

Package

cambl

Source

cambl.lisp (file)

Function: value-greatereqp LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-greatereqp* LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-greaterp LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-greaterp* LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-lesseqp LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-lesseqp* LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-lessp LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-lessp* LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value-maybe-round AMOUNT
Package

cambl

Source

cambl.lisp (file)

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 (file)

Function: value< LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value<= LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value> LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: value>= LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: valuep OBJECT
Package

cambl

Source

cambl.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: add VALUE-A VALUE-B
Package

cambl

Source

cambl.lisp (file)

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 (file)

Methods
Method: amount-precision (ITEM amount)
Method: amount-precision (ITEM rational)
Generic Function: annotate-commodity ITEM ANNOTATION
Package

cambl

Source

cambl.lisp (file)

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 (file)

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 (file)

Methods
Method: commodity-annotation-equal (A commodity-annotation) (B commodity-annotation)
Generic Function: commodity-name ITEM &optional NO-ANNOTATION
Package

cambl

Source

cambl.lisp (file)

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 Function: commodity-qualified-name OBJECT
Generic Function: (setf commodity-qualified-name) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf commodity-qualified-name) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: compare LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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)

Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Conditions

Condition: amount-error ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: description
Initargs

:msg

Readers

error-description (generic function)

Slot: operands
Initargs

:operands

Readers

error-operands (generic function)

Condition: commodity-error ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: description
Initargs

:msg

Readers

error-description (generic function)

Slot: commodity
Initargs

:commodity

Initform

(quote nil)

Readers

error-commodity (generic function)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 Structures

Structure: amount ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: commodity
Type

(or cambl::commodity null)

Readers

amount-commodity (function)

Writers

(setf amount-commodity) (function)

Slot: quantity
Type

rational

Initform

0

Readers

amount-quantity (function)

Writers

(setf amount-quantity) (function)

Slot: full-precision
Type

cambl::fixnum+

Initform

0

Readers

amount-full-precision (function)

Writers

(setf amount-full-precision) (function)

Slot: keep-precision-p
Type

boolean

Readers

amount-keep-precision-p (function)

Writers

(setf amount-keep-precision-p) (function)

Structure: commodity-annotation ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: price
Readers

annotation-price (function)

Writers

(setf annotation-price) (function)

Slot: date
Type

(or periods:fixed-time null)

Readers

annotation-date (function)

Writers

(setf annotation-date) (function)

Slot: tag
Type

(or string null)

Readers

annotation-tag (function)

Writers

(setf annotation-tag) (function)

Structure: commodity-pool ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: by-name-map
Type

hash-table

Initform

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

Readers

commodity-pool-by-name-map (function)

Writers

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

Slot: default-commodity
Readers

commodity-pool-default-commodity (function)

Writers

(setf commodity-pool-default-commodity) (function)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.7 Classes

Class: annotated-commodity ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

commodity (class)

Direct methods
Direct slots
Slot: referent
Type

cambl::commodity

Initargs

:referent

Readers

get-referent (generic function)

Writers

(setf get-referent) (generic function)

Slot: annotation
Type

cambl:commodity-annotation

Initargs

:annotation

Readers

get-commodity-annotation (generic function)

Writers

(setf get-commodity-annotation) (generic function)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.8 Types

Type: value ()
Package

cambl

Source

cambl.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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 (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: define-commodity-accessor FUNCTION ACCESSOR
Package

cambl

Source

cambl.lisp (file)

Macro: transform-balance BALANCE PREDICATE FUNCTION &key FIRST-ONLY SKIP-TO-NEXT LOOKAHEAD
Package

cambl

Source

cambl.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: add-price COMMODITY PRICE &optional FIXED-TIME
Package

cambl

Source

cambl.lisp (file)

Function: amount-full-precision INSTANCE
Function: (setf amount-full-precision) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: apply-between-amounts LEFT RIGHT FUNCTION &optional ADJUSTOR
Package

cambl

Source

cambl.lisp (file)

Function: apply-between-balances LEFT RIGHT FUNCTION &optional ADJUSTOR
Package

cambl

Source

cambl.lisp (file)

Function: apply-to-balance BALANCE COMMODITY VALUE FUNCTION &optional ADJUSTOR
Package

cambl

Source

cambl.lisp (file)

Function: balance &rest AMOUNTS
Package

cambl

Source

cambl.lisp (file)

Function: balance-equal LEFT RIGHT TEST-FUNC
Package

cambl

Source

cambl.lisp (file)

Function: balance-helper LEFT RIGHT
Package

cambl

Source

cambl.lisp (file)

Function: commodity-annotation-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: commodity-comment COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-comment) (setf expander)

Setf Expander: (setf commodity-comment) COMM
Package

cambl

Source

cambl.lisp (file)

Reader

commodity-comment (function)

Function: commodity-description COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-description) (setf expander)

Setf Expander: (setf commodity-description) COMM
Package

cambl

Source

cambl.lisp (file)

Reader

commodity-description (function)

Function: commodity-pool-by-name-map INSTANCE
Function: (setf commodity-pool-by-name-map) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: commodity-pool-default-commodity INSTANCE
Function: (setf commodity-pool-default-commodity) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: commodity-pool-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: commodity-symbol COMM
Package

cambl

Source

cambl.lisp (file)

Setf Expander

(setf commodity-symbol) (setf expander)

Setf Expander: (setf commodity-symbol) COMM
Package

cambl

Source

cambl.lisp (file)

Reader

commodity-symbol (function)

Function: commodity-symbol-connected-p INSTANCE
Function: (setf commodity-symbol-connected-p) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: commodity-symbol-name INSTANCE
Function: (setf commodity-symbol-name) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: commodity-symbol-needs-quoting-p INSTANCE
Function: (setf commodity-symbol-needs-quoting-p) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: commodity-symbol-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: commodity-symbol-prefixed-p INSTANCE
Function: (setf commodity-symbol-prefixed-p) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: copy-amount INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: copy-balance INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: copy-commodity-annotation INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: copy-commodity-pool INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: copy-commodity-symbol INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: copy-pricing-entry INSTANCE
Package

cambl

Source

cambl.lisp (file)

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 (file)

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 (file)

Function: divide-in-balance BALANCE COMMODITY VALUE
Package

cambl

Source

cambl.lisp (file)

Function: find-nearest HISTORY FIXED-TIME
Package

cambl

Source

cambl.lisp (file)

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 (file)

Function: make-amount &key (COMMODITY COMMODITY) (QUANTITY QUANTITY) (FULL-PRECISION FULL-PRECISION) (KEEP-PRECISION-P KEEP-PRECISION-P)
Package

cambl

Source

cambl.lisp (file)

Function: make-balance &key (AMOUNTS-MAP AMOUNTS-MAP)
Package

cambl

Source

cambl.lisp (file)

Function: make-commodity-symbol &key (NAME NAME) (NEEDS-QUOTING-P NEEDS-QUOTING-P) (PREFIXED-P PREFIXED-P) (CONNECTED-P CONNECTED-P)
Package

cambl

Source

cambl.lisp (file)

Function: make-pricing-entry &key (MOMENT MOMENT) (PRICE PRICE)
Package

cambl

Source

cambl.lisp (file)

Function: make-qualified-name COMMODITY COMMODITY-ANNOTATION
Package

cambl

Source

cambl.lisp (file)

Function: multiply-in-balance BALANCE COMMODITY VALUE
Package

cambl

Source

cambl.lisp (file)

Function: peek-char-in-line IN &optional SKIP-WHITESPACE
Package

cambl

Source

cambl.lisp (file)

Function: pricing-entry-moment INSTANCE
Function: (setf pricing-entry-moment) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: pricing-entry-p OBJECT
Package

cambl

Source

cambl.lisp (file)

Function: pricing-entry-price INSTANCE
Function: (setf pricing-entry-price) VALUE INSTANCE
Package

cambl

Source

cambl.lisp (file)

Function: print-amount AMOUNT STREAM DEPTH
Package

cambl

Source

cambl.lisp (file)

Function: print-balance BALANCE STREAM DEPTH
Package

cambl

Source

cambl.lisp (file)

Function: print-value-to-string COMMODITY COMMODITY-SYMBOL QUANTITY PRECISION OUTPUT-STREAM
Package

cambl

Source

cambl.lisp (file)

Function: read-amount-quantity IN
Package

cambl

Source

cambl.lisp (file)

Function: read-commodity-annotation IN
Package

cambl

Source

cambl.lisp (file)

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 (file)

Function: read-until IN CHAR &optional ERROR-MESSAGE
Package

cambl

Source

cambl.lisp (file)

Function: remove-price COMMODITY FIXED-TIME
Package

cambl

Source

cambl.lisp (file)

Function: symbol-char-invalid-p C
Package

cambl

Source

cambl.lisp (file)

Function: symbol-name-needs-quoting-p NAME

Return T if the given symbol NAME requires quoting.

Package

cambl

Source

cambl.lisp (file)

Function: timing-tests &optional LOOP-COUNT
Package

fprog

Source

fprog.lisp (file)

Function: verify-amounts LEFT RIGHT CAPITALIZED-GERUND
Package

cambl

Source

cambl.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: commodity-annotation-empty-p ITEM
Package

cambl

Source

cambl.lisp (file)

Methods
Method: commodity-annotation-empty-p (ANNOTATION commodity-annotation)
Generic Function: error-commodity CONDITION
Package

cambl

Methods
Method: error-commodity (CONDITION commodity-error)
Source

cambl.lisp (file)

Generic Function: error-description CONDITION
Package

cambl

Methods
Method: error-description (CONDITION commodity-error)
Source

cambl.lisp (file)

Method: error-description (CONDITION amount-error)
Source

cambl.lisp (file)

Generic Function: error-operands CONDITION
Package

cambl

Methods
Method: error-operands (CONDITION amount-error)
Source

cambl.lisp (file)

Generic Function: get-builtin-p OBJECT
Generic Function: (setf get-builtin-p) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-builtin-p) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-comment OBJECT
Generic Function: (setf get-comment) NEW-VALUE OBJECT
Package

cambl

Methods
Method: get-comment (COMMODITY commodity)

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-comment) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-commodity-annotation OBJECT
Generic Function: (setf get-commodity-annotation) NEW-VALUE OBJECT
Package

cambl

Methods
Method: get-commodity-annotation (ANNOTATED-COMMODITY annotated-commodity)

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-commodity-annotation) NEW-VALUE (ANNOTATED-COMMODITY annotated-commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-commodity-pool OBJECT
Generic Function: (setf get-commodity-pool) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-commodity-pool) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-description OBJECT
Generic Function: (setf get-description) NEW-VALUE OBJECT
Package

cambl

Methods
Method: get-description (COMMODITY commodity)

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-description) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-display-precision OBJECT
Generic Function: (setf get-display-precision) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-display-precision) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-european-style-p OBJECT
Generic Function: (setf get-european-style-p) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-european-style-p) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-no-market-price-p OBJECT
Generic Function: (setf get-no-market-price-p) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-no-market-price-p) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-price-history OBJECT
Generic Function: (setf get-price-history) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-price-history) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-referent OBJECT
Generic Function: (setf get-referent) NEW-VALUE OBJECT
Package

cambl

Methods
Method: get-referent (ANNOTATED-COMMODITY annotated-commodity)

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-referent) NEW-VALUE (ANNOTATED-COMMODITY annotated-commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-symbol OBJECT
Generic Function: (setf get-symbol) NEW-VALUE OBJECT
Package

cambl

Methods
Method: get-symbol (COMMODITY commodity)

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-symbol) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)

Generic Function: get-thousand-marks-p OBJECT
Generic Function: (setf get-thousand-marks-p) NEW-VALUE OBJECT
Package

cambl

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

automatically generated reader method

Source

cambl.lisp (file)

Method: (setf get-thousand-marks-p) NEW-VALUE (COMMODITY commodity)

automatically generated writer method

Source

cambl.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Structures

Structure: balance ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods
Direct slots
Slot: amounts-map
Readers

get-amounts-map (function)

Writers

(setf get-amounts-map) (function)

Structure: commodity-symbol ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Type

string

Initform

""

Readers

commodity-symbol-name (function)

Writers

(setf commodity-symbol-name) (function)

Slot: needs-quoting-p
Type

boolean

Readers

commodity-symbol-needs-quoting-p (function)

Writers

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

Slot: prefixed-p
Type

boolean

Readers

commodity-symbol-prefixed-p (function)

Writers

(setf commodity-symbol-prefixed-p) (function)

Slot: connected-p
Type

boolean

Readers

commodity-symbol-connected-p (function)

Writers

(setf commodity-symbol-connected-p) (function)

Structure: pricing-entry ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: moment
Readers

pricing-entry-moment (function)

Writers

(setf pricing-entry-moment) (function)

Slot: price
Readers

pricing-entry-price (function)

Writers

(setf pricing-entry-price) (function)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Classes

Class: commodity ()
Package

cambl

Source

cambl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

annotated-commodity (class)

Direct methods
Direct slots
Slot: symbol
Initargs

:symbol

Readers

get-symbol (generic function)

Writers

(setf get-symbol) (generic function)

Slot: description
Type

(or string null)

Initargs

:description

Readers

get-description (generic function)

Writers

(setf get-description) (generic function)

Slot: comment
Type

(or string null)

Initargs

:comment

Readers

get-comment (generic function)

Writers

(setf get-comment) (generic function)

Slot: thousand-marks-p
Type

boolean

Initargs

:thousand-marks-p

Readers

get-thousand-marks-p (generic function)

Writers

(setf get-thousand-marks-p) (generic function)

Slot: european-style-p
Type

boolean

Initargs

:european-style-p

Readers

get-european-style-p (generic function)

Writers

(setf get-european-style-p) (generic function)

Slot: no-market-price-p
Type

boolean

Initargs

:no-market-price-p

Readers

get-no-market-price-p (generic function)

Writers

(setf get-no-market-price-p) (generic function)

Slot: builtin-p
Type

boolean

Initargs

:builtin-p

Readers

get-builtin-p (generic function)

Writers

(setf get-builtin-p) (generic function)

Slot: display-precision
Type

cambl::fixnum+

Initargs

:display-precision

Initform

0

Readers

get-display-precision (generic function)

Writers

(setf get-display-precision) (generic function)

Slot: price-history
Initargs

:price-history

Readers

get-price-history (generic function)

Writers

(setf get-price-history) (generic function)

Slot: commodity-pool
Type

cambl:commodity-pool

Initargs

:commodity-pool

Readers

get-commodity-pool (generic function)

Writers

(setf get-commodity-pool) (generic function)

Slot: qualified-name
Type

(or string null)

Initargs

:qualified-name

Readers

commodity-qualified-name (generic function)

Writers

(setf commodity-qualified-name) (generic function)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.7 Types

Type: fixnum+ ()
Package

cambl

Source

cambl.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cambl.asd: The cambl<dot>asd file
cambl/cambl.lisp: The cambl/cambl<dot>lisp file

F
File, Lisp, cambl.asd: The cambl<dot>asd file
File, Lisp, cambl/cambl.lisp: The cambl/cambl<dot>lisp file
File, Lisp, fprog.asd: The fprog<dot>asd file
File, Lisp, fprog/fprog.lisp: The fprog/fprog<dot>lisp file
fprog.asd: The fprog<dot>asd file
fprog/fprog.lisp: The fprog/fprog<dot>lisp file

L
Lisp File, cambl.asd: The cambl<dot>asd file
Lisp File, cambl/cambl.lisp: The cambl/cambl<dot>lisp file
Lisp File, fprog.asd: The fprog<dot>asd file
Lisp File, fprog/fprog.lisp: The fprog/fprog<dot>lisp file

Jump to:   C   F   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

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): Exported functions
(setf amount-full-precision): Internal functions
(setf amount-keep-precision-p): Exported functions
(setf amount-quantity): Exported functions
(setf annotation-date): Exported functions
(setf annotation-price): Exported functions
(setf annotation-tag): Exported functions
(setf commodity-builtin-p): Exported functions
(setf commodity-comment): Internal functions
(setf commodity-description): Internal functions
(setf commodity-european-style-p): Exported functions
(setf commodity-no-market-price-p): Exported functions
(setf commodity-pool): Exported functions
(setf commodity-pool-by-name-map): Internal functions
(setf commodity-pool-default-commodity): Internal functions
(setf commodity-price-history): Exported functions
(setf commodity-qualified-name): Exported generic functions
(setf commodity-qualified-name): Exported generic functions
(setf commodity-symbol): Internal functions
(setf commodity-symbol-connected-p): Internal functions
(setf commodity-symbol-name): Internal functions
(setf commodity-symbol-needs-quoting-p): Internal functions
(setf commodity-symbol-prefixed-p): Internal functions
(setf commodity-thousand-marks-p): Exported functions
(setf get-amounts-map): Exported functions
(setf get-builtin-p): Internal generic functions
(setf get-builtin-p): Internal generic functions
(setf get-comment): Internal generic functions
(setf get-comment): Internal generic functions
(setf get-commodity-annotation): Internal generic functions
(setf get-commodity-annotation): Internal generic functions
(setf get-commodity-pool): Internal generic functions
(setf get-commodity-pool): Internal generic functions
(setf get-description): Internal generic functions
(setf get-description): Internal generic functions
(setf get-display-precision): Internal generic functions
(setf get-display-precision): Internal generic functions
(setf get-european-style-p): Internal generic functions
(setf get-european-style-p): Internal generic functions
(setf get-no-market-price-p): Internal generic functions
(setf get-no-market-price-p): Internal generic functions
(setf get-price-history): Internal generic functions
(setf get-price-history): Internal generic functions
(setf get-referent): Internal generic functions
(setf get-referent): Internal generic functions
(setf get-symbol): Internal generic functions
(setf get-symbol): Internal generic functions
(setf get-thousand-marks-p): Internal generic functions
(setf get-thousand-marks-p): Internal generic functions
(setf pricing-entry-moment): Internal functions
(setf pricing-entry-price): Internal functions

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

B
balance: Internal functions
balance-amounts: Exported functions
balance-commodities: Exported functions
balance-commodity-count: Exported functions
balance-equal: Internal functions
balance-first-amount: Exported functions
balance-helper: Internal functions
balance-p: Exported functions

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

D
define-commodity-accessor: Internal macros
display-precision: Exported generic functions
display-precision: Exported generic functions
display-precision: Exported generic functions
display-precision: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide: Exported generic functions
divide-in-balance: Internal functions

E
error-commodity: Internal generic functions
error-commodity: Internal generic functions
error-description: Internal generic functions
error-description: Internal generic functions
error-description: Internal generic functions
error-operands: Internal generic functions
error-operands: Internal generic functions
exact-amount: Exported functions
exchange-commodity: Exported functions

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

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

I
insert-if: Exported functions

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

N
negate: Exported generic functions
negate: Exported generic functions
negate: Exported generic functions
negate: Exported generic functions

P
parse-amount: Exported functions
parse-amount*: Exported functions
peek-char-in-line: Internal functions
pricing-entry-moment: Internal functions
pricing-entry-p: Internal functions
pricing-entry-price: Internal functions
print-amount: Internal functions
print-balance: Internal functions
print-value: Exported generic functions
print-value: Exported generic functions
print-value: Exported generic functions
print-value: Exported generic functions
print-value: Exported generic functions
print-value-to-string: Internal functions
pushend: Exported macros

R
read-amount: Exported functions
read-amount*: Exported functions
read-amount-quantity: Internal functions
read-commodity-annotation: Internal functions
read-commodity-symbol: Internal functions
read-exact-amount: Exported functions
read-until: Internal functions
remove-if: Exported functions
remove-price: Internal functions
reset-commodity-pool: Exported functions

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

T
timing-tests: Internal functions
transform-balance: Internal macros

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

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

Next: , Previous: , Up: Indexes   [Contents][Index]

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*: Exported special variables
*default-display-precision*: Exported special variables
*extra-precision*: Exported special variables
*invalid-symbol-chars*: Internal special variables

A
amounts-map: Internal structures
annotation: Exported classes

B
builtin-p: Internal classes
by-name-map: Exported structures

C
comment: Internal classes
commodity: Exported conditions
commodity: Exported structures
commodity-pool: Internal classes
connected-p: Internal structures

D
date: Exported structures
default-commodity: Exported structures
description: Exported conditions
description: Exported conditions
description: Internal classes
display-precision: Internal classes

E
european-style-p: Internal classes

F
full-precision: Exported structures

K
keep-precision-p: Exported structures

M
moment: Internal structures

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

O
operands: Exported conditions

P
prefixed-p: Internal structures
price: Exported structures
price: Internal structures
price-history: Internal classes

Q
qualified-name: Internal classes
quantity: Exported structures

R
referent: Exported classes

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

T
tag: Exported structures
thousand-marks-p: Internal classes

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

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

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

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

B
balance: Internal structures

C
cambl: The cambl system
cambl: The cambl package
Class, annotated-commodity: Exported classes
Class, commodity: Internal classes
commodity: Internal classes
commodity-annotation: Exported structures
commodity-error: Exported conditions
commodity-pool: Exported structures
commodity-symbol: Internal structures
Condition, amount-error: Exported conditions
Condition, commodity-error: Exported conditions

F
fixnum+: Internal types
fprog: The fprog system
fprog: The fprog package

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

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

T
Type, fixnum+: Internal types
Type, value: Exported types

V
value: Exported types

Jump to:   A   B   C   F   P   S   T   V