(require 'logical) or (require 'srfi-60)
The bit-twiddling functions are made available through the use of the
logical package. logical is loaded by inserting
(require 'logical) before the code that uses these functions.
These functions behave as though operating on integers in
two's-complement representation.
Example:
(number->string (logand #b1100 #b1010) 2) => "1000"
Example:
(number->string (logior #b1100 #b1010) 2) => "1110"
Example:
(number->string (logxor #b1100 #b1010) 2) => "110"
Example:
(number->string (lognot #b10000000) 2) => "-10000001" (number->string (lognot #b0) 2) => "-1"
(logtest j k) == (not (zero? (logand j k))) (logtest #b0100 #b1011) => #f (logtest #b0100 #b0111) => #t
Example:
(logcount #b10101010) => 4 (logcount 0) => 0 (logcount -2) => 1
On discuss@r6rs.org Ben Harris credits Simon Tatham with the
idea to have bitwise-bit-count return a negative count for
negative inputs. Alan Bawden came up with the succinct invariant.
(bitwise-not (bitwise-bit-count (bitwise-not n)))
Example:
(integer-length #b10101010) => 8 (integer-length 0) => 0 (integer-length #b1111) => 4
(require 'printf)
(do ((idx 0 (+ 1 idx)))
((> idx 16))
(printf "%s(%3d) ==> %-5d %s(%2d) ==> %-5d\n"
'log2-binary-factors
(- idx) (log2-binary-factors (- idx))
'log2-binary-factors
idx (log2-binary-factors idx)))
-|
log2-binary-factors( 0) ==> -1 log2-binary-factors( 0) ==> -1
log2-binary-factors( -1) ==> 0 log2-binary-factors( 1) ==> 0
log2-binary-factors( -2) ==> 1 log2-binary-factors( 2) ==> 1
log2-binary-factors( -3) ==> 0 log2-binary-factors( 3) ==> 0
log2-binary-factors( -4) ==> 2 log2-binary-factors( 4) ==> 2
log2-binary-factors( -5) ==> 0 log2-binary-factors( 5) ==> 0
log2-binary-factors( -6) ==> 1 log2-binary-factors( 6) ==> 1
log2-binary-factors( -7) ==> 0 log2-binary-factors( 7) ==> 0
log2-binary-factors( -8) ==> 3 log2-binary-factors( 8) ==> 3
log2-binary-factors( -9) ==> 0 log2-binary-factors( 9) ==> 0
log2-binary-factors(-10) ==> 1 log2-binary-factors(10) ==> 1
log2-binary-factors(-11) ==> 0 log2-binary-factors(11) ==> 0
log2-binary-factors(-12) ==> 2 log2-binary-factors(12) ==> 2
log2-binary-factors(-13) ==> 0 log2-binary-factors(13) ==> 0
log2-binary-factors(-14) ==> 1 log2-binary-factors(14) ==> 1
log2-binary-factors(-15) ==> 0 log2-binary-factors(15) ==> 0
log2-binary-factors(-16) ==> 4 log2-binary-factors(16) ==> 4
(logbit? index n) == (logtest (expt 2 index) n) (logbit? 0 #b1101) => #t (logbit? 1 #b1101) => #f (logbit? 2 #b1101) => #t (logbit? 3 #b1101) => #t (logbit? 4 #b1101) => #f
#t and 0 if bit is #f.
Example:
(number->string (copy-bit 0 0 #t) 2) => "1" (number->string (copy-bit 2 0 #t) 2) => "100" (number->string (copy-bit 2 #b1111 #f) 2) => "1011"
Example:
(number->string (bit-field #b1101101010 0 4) 2) => "1010" (number->string (bit-field #b1101101010 4 9) 2) => "10110"
Example:
(number->string (copy-bit-field #b1101101010 0 0 4) 2)
=> "1101100000"
(number->string (copy-bit-field #b1101101010 -1 0 4) 2)
=> "1101101111"
(number->string (copy-bit-field #b110100100010000 -1 5 9) 2)
=> "110100111110000"
(inexact->exact (floor (* n (expt 2 count)))).
Example:
(number->string (ash #b1 3) 2) => "1000" (number->string (ash #b1010 -1) 2) => "101"
Example:
(number->string (rotate-bit-field #b0100 3 0 4) 2)
=> "10"
(number->string (rotate-bit-field #b0100 -1 0 4) 2)
=> "10"
(number->string (rotate-bit-field #b110100100010000 -1 5 9) 2)
=> "110100010010000"
(number->string (rotate-bit-field #b110100100010000 1 5 9) 2)
=> "110100000110000"
(number->string (reverse-bit-field #xa7 0 8) 16) => "e5"
integer->list returns a list of len booleans corresponding
to each bit of the given integer. #t is coded for each 1; #f for 0.
The len argument defaults to (integer-length k).
list->integer returns an integer formed from the booleans in the
list list, which must be a list of booleans. A 1 bit is coded for
each #t; a 0 bit for #f.
integer->list and list->integer are inverses so far as
equal? is concerned.
Returns a list of 3 integers (d x y) such that d = gcd(n1,
n2) = n1 * x + n2 * y.
For odd positive integer m, returns an object suitable for passing
as the first argument to modular: procedures, directing them
to return a symmetric modular number, ie. an n such that
(<= (quotient m -2) n (quotient m 2)
Returns the non-negative integer characteristic of the ring formed when
modulus is used with modular: procedures.
Returns the integer (modulo n (modular:characteristic
modulus)) in the representation specified by modulus.
The rest of these functions assume normalized arguments; That is, the arguments are constrained by the following table:
For all of these functions, if the first argument (modulus) is:
positive?
zero?
Otherwise, if modulus is a value returned by
(symmetric:modulus radix), then the arguments and
result are treated as members of the integers modulo radix,
but with symmetric representation; i.e.
(<= (quotient radix 2) n (quotient (- -1 radix) 2)
If all the arguments are fixnums the computation will use only fixnums.
Returns #t if there exists an integer n such that k * n
== 1 mod modulus, and #f otherwise.
Returns an integer n such that 1 = (n * n2) mod modulus. If n2 has no inverse mod modulus an error is signaled.
Returns (-n2) mod modulus.
Returns (n2 + n3) mod modulus.
Returns (n2 - n3) mod modulus.
Returns (n2 * n3) mod modulus.
The Scheme code for modular:* with negative modulus is
not completed for fixnum-only implementations.
Returns (n2 ^ n3) mod modulus.
Returns n1 raised to the power n2 if that result is an exact integer; otherwise signals an error.
(integer-expt 0 n2)
returns 1 for n2 equal to 0; returns 0 for positive integer n2; signals an error otherwise.
Returns the largest exact integer whose power of base is less than or
equal to k. If base or k is not a positive exact integer, then
integer-log signals an error.
For non-negative integer k returns the largest integer whose square is less than or equal to k; otherwise signals an error.
are redefined so that they accept only exact-integer arguments.
Although this package defines real and complex functions, it is safe to load into an integer-only implementation; those functions will be defined to #f.
These procedures are part of every implementation that supports
general real numbers; they compute the usual transcendental functions.
`real-ln' computes the natural logarithm of x;
`real-log' computes the logarithm of x base y, which
is (/ (real-ln x) (real-ln y)). If arguments x and
y are not both real; or if the correct result would not be real,
then these procedures signal an error.
For non-negative real x the result will be its positive square root; otherwise an error will be signaled.
Returns x1 raised to the power x2 if that result is a real number; otherwise signals an error.
(real-expt 0.0 x2)
x2 should be non-zero.
(quo x1 x2) ==> n_q
(rem x1 x2) ==> x_r
(mod x1 x2) ==> x_m
where n_q is x1/x2 rounded towards zero, 0 < |x_r| < |x2|, 0 < |x_m| < |x2|, x_r and x_m differ from x1 by a multiple of x2, x_r has the same sign as x1, and x_m has the same sign as x2.
From this we can conclude that for x2 not equal to 0,
(= x1 (+ (* x2 (quo x1 x2))
(rem x1 x2)))
==> #t
provided all numbers involved in that computation are exact.
(quo 2/3 1/5) ==> 3
(mod 2/3 1/5) ==> 1/15
(quo .666 1/5) ==> 3.0
(mod .666 1/5) ==> 65.99999999999995e-3
These procedures are part of every implementation that supports general real numbers. `Ln' computes the natural logarithm of z
In general, the mathematical function ln is multiply defined. The value of ln z is defined to be the one whose imaginary part lies in the range from -pi (exclusive) to pi (inclusive).
For real argument x, `Abs' returns the absolute value of x' otherwise it signals an error.
(abs -7) ==> 7
These procedures are part of every implementation that supports general complex numbers. Suppose x1, x2, x3, and x4 are real numbers and z is a complex number such that
z = x1 + x2i = x3 . e^i x4
Then
(make-rectangular x1 x2) ==> z (make-polar x3 x4) ==> z
where -pi < x_angle <= pi with x_angle = x4 + 2pi n for some integer n.
If an argument is not real, then these procedures signal an error.
prime:prngs is the random-state (see section Random Numbers) used by these
procedures. If you call these procedures from more than one thread
(or from interrupt), random may complain about reentrant
calls.
Returns the value (+1, -1, or 0) of the Jacobi-Symbol of exact non-negative integer p and exact positive odd integer q.
prime:trials the maxinum number of iterations of Solovay-Strassen that will be done to test a number for primality.
Returns #f if n is composite; #t if n is prime.
There is a slight chance (expt 2 (- prime:trials)) that a
composite will return #t.
Returns a list of the first count prime numbers less than start. If there are fewer than count prime numbers less than start, then the returned list will have fewer than start elements.
Returns a list of the first count prime numbers greater than start.
Returns a list of the prime factors of k. The order of the
factors is unspecified. In order to obtain a sorted list do
(sort! (factor k) <).
A pseudo-random number generator is only as good as the tests it passes. George Marsaglia of Florida State University developed a battery of tests named DIEHARD (http://stat.fsu.edu/~geo/diehard.html). `diehard.c' has a bug which the patch http://swiss.csail.mit.edu/ftpdir/users/jaffer/diehard.c.pat corrects.
SLIB's PRNG generates 8 bits at a time. With the degenerate seed `0', the numbers generated pass DIEHARD; but when bits are combined from sequential bytes, tests fail. With the seed `http://swissnet.ai.mit.edu/~jaffer/SLIB.html', all of those tests pass.
n must be an exact positive integer. random returns an exact integer
between zero (inclusive) and n (exclusive). The values returned by
random are uniformly distributed from 0 to n.
The optional argument state must be of the type returned by
(seed->random-state) or (make-random-state). It
defaults to the value of the variable *random-state*. This
object is used to maintain the state of the pseudo-random-number
generator and is altered as a side effect of calls to random.
random uses by default. The nature
of this data structure is implementation-dependent. It may be printed
out and successfully read back in, but may or may not function correctly
as a random-number state object in another implementation.
Returns a new copy of argument state.
*random-state*.
Returns a new object of type suitable for use as the value of the
variable *random-state* or as a second argument to random.
The number or string seed is used to initialize the state. If
seed->random-state is called twice with arguments which are
equal?, then the returned data structures will be equal?.
Calling seed->random-state with unequal arguments will nearly
always return unequal states.
*random-state* or as a second argument to random.
If the optional argument obj is given, it should be a printable
Scheme object; the first 50 characters of its printed representation
will be used as the seed. Otherwise the value of *random-state*
is used as the seed.
(* u (random:exp)).
(+ m (* d (random:normal))).
(vector-length vect), the coordinates are
uniformly distributed over the surface of the unit n-shere.
(vector-length vect), the
coordinates are uniformly distributed within the unit n-shere.
The sum of the squares of the numbers is returned.
(require 'dft) or
(require 'Fourier-transform)
fft and fft-1 compute the Fast-Fourier-Transforms
(O(n*log(n))) of arrays whose dimensions are all powers of 2.
sft and sft-1 compute the Discrete-Fourier-Transforms
for all combinations of dimensions (O(n^2)).
sft returns an
array of type prot (defaulting to array) of complex numbers comprising
the Discrete Fourier Transform of array.
sft-1 returns an
array of type prot (defaulting to array) of complex numbers comprising
the inverse Discrete Fourier Transform of array.
fft returns an array of type prot (defaulting to
array) of complex numbers comprising the Discrete Fourier Transform of
array.
fft-1 returns an array of type prot (defaulting
to array) of complex numbers comprising the inverse Discrete Fourier
Transform of array.
dft and dft-1 compute the discrete Fourier transforms
using the best method for decimating each dimension.
dft returns an array of type prot (defaulting to array) of complex
numbers comprising the Discrete Fourier Transform of array.
dft-1 returns an array of type prot (defaulting to array) of
complex numbers comprising the inverse Discrete Fourier Transform of
array.
(fft-1 (fft array)) will return an array of values close to
array.
(fft '#(1 0+i -1 0-i 1 0+i -1 0-i)) => #(0.0 0.0 0.0+628.0783185208527e-18i 0.0 0.0 0.0 8.0-628.0783185208527e-18i 0.0) (fft-1 '#(0 0 0 0 0 0 8 0)) => #(1.0 -61.23031769111886e-18+1.0i -1.0 61.23031769111886e-18-1.0i 1.0 -61.23031769111886e-18+1.0i -1.0 61.23031769111886e-18-1.0i)
(require 'crc)
Cyclic Redundancy Checks using Galois field GF(2) polynomial
arithmetic are used for error detection in many data transmission
and storage applications.
The generator polynomials for various CRC protocols are availble from many sources. But the polynomial is just one of many parameters which must match in order for a CRC implementation to interoperate with existing systems:
The performance of a particular CRC polynomial over packets of given sizes varies widely. In terms of the probability of undetected errors, some uses of extant CRC polynomials are suboptimal by several orders of magnitude.
If you are considering CRC for a new application, consult the following article to find the optimum CRC polynomial for your range of data lengths:
http://www.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf
There is even some controversy over the polynomials themselves.
But http://www.cs.ncl.ac.uk/people/harry.whitfield/home.formal/CRCs.html, http://duchon.umuc.edu/Web_Pages/duchon/99_f_cm435/ShiftRegister.htm, http://spinroot.com/spin/Doc/Book91_PDF/ch3.pdf, http://www.erg.abdn.ac.uk/users/gorry/course/dl-pages/crc.html, http://www.rad.com/networks/1994/err_con/crc_most.htm, and http://www.gpfn.sk.ca/~rhg/csc8550s02/crc.html, http://www.nobugconsulting.ro/crc.php give x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
SLIB crc-32-polynomial uses the latter definition.
http://www.math.grin.edu/~rebelsky/Courses/CS364/2000S/Outlines/outline.12.html, http://duchon.umuc.edu/Web_Pages/duchon/99_f_cm435/ShiftRegister.htm, http://www.cs.ncl.ac.uk/people/harry.whitfield/home.formal/CRCs.html, http://www2.sis.pitt.edu/~jkabara/tele-2100/lect08.html, and http://www.gpfn.sk.ca/~rhg/csc8550s02/crc.html give CRC-CCITT: x^16+x^12+x^5+1.
http://www.math.grin.edu/~rebelsky/Courses/CS364/2000S/Outlines/outline.12.html, http://duchon.umuc.edu/Web_Pages/duchon/99_f_cm435/ShiftRegister.htm, http://www.cs.ncl.ac.uk/people/harry.whitfield/home.formal/CRCs.html, http://www.gpfn.sk.ca/~rhg/csc8550s02/crc.html, and http://www.usb.org/developers/data/crcdes.pdf give CRC-16: x^16+x^15+x^2+1.
http://www.math.grin.edu/~rebelsky/Courses/CS364/2000S/Outlines/outline.12.html, http://www.cs.ncl.ac.uk/people/harry.whitfield/home.formal/CRCs.html, http://www.it.iitb.ac.in/it605/lectures/link/node4.html, and http://spinroot.com/spin/Doc/Book91_PDF/ch3.pdf give CRC-12: x^12+x^11+x^3+x^2+1.
But http://www.ffldusoe.edu/Faculty/Denenberg/Topics/Networks/Error_Detection_Correction/crc.html, http://duchon.umuc.edu/Web_Pages/duchon/99_f_cm435/ShiftRegister.htm, http://www.eng.uwi.tt/depts/elec/staff/kimal/errorcc.html, http://www.ee.uwa.edu.au/~roberto/teach/itc314/java/CRC/, http://www.gpfn.sk.ca/~rhg/csc8550s02/crc.html, and http://www.efg2.com/Lab/Mathematics/CRC.htm give CRC-12: x^12+x^11+x^3+x^2+x+1.
These differ in bit 1 and calculations using them return different values. With citations near evenly split, it is hard to know which is correct. Thanks to Philip Koopman for breaking the tie in favor of the latter (#xC07).
http://www.math.grin.edu/~rebelsky/Courses/CS364/2000S/Outlines/outline.12.html gives CRC-10: x^10+x^9+x^5+x^4+1; but http://cell-relay.indiana.edu/cell-relay/publications/software/CRC/crc10.html, http://www.it.iitb.ac.in/it605/lectures/link/node4.html, http://www.gpfn.sk.ca/~rhg/csc8550s02/crc.html, http://www.techfest.com/networking/atm/atm.htm, http://www.protocols.com/pbook/atmcell2.htm, and http://www.nobugconsulting.ro/crc.php give CRC-10: x^10+x^9+x^5+x^4+x+1.
http://www.math.grin.edu/~rebelsky/Courses/CS364/2000S/Outlines/outline.12.html, http://www.cs.ncl.ac.uk/people/harry.whitfield/home.formal/CRCs.html, http://www.it.iitb.ac.in/it605/lectures/link/node4.html, and http://www.nobugconsulting.ro/crc.php give CRC-8: x^8+x^2+x^1+1
http://cell-relay.indiana.edu/cell-relay/publications/software/CRC/32bitCRC.tutorial.html and http://www.gpfn.sk.ca/~rhg/csc8550s02/crc.html give ATM HEC: x^8+x^2+x+1.
http://www.cs.ncl.ac.uk/people/harry.whitfield/home.formal/CRCs.html gives DOWCRC: x^8+x^5+x^4+1.
http://www.usb.org/developers/data/crcdes.pdf and http://www.nobugconsulting.ro/crc.php give USB-token: x^5+x^2+1.
Each of these polynomial constants is a string of `1's and `0's, the exponent of each power of x in descending order.
poly must be string of `1's and `0's beginning with
`1' and having length greater than 8. crc:make-table
returns a vector of 256 integers, such that:
(set! crc
(logxor (ash (logand (+ -1 (ash 1 (- deg 8))) crc) 8)
(vector-ref crc-table
(logxor (ash crc (- 8 deg)) byte))))
will compute the crc with the 8 additional bits in byte;
where crc is the previous accumulated CRC value, deg is
the degree of poly, and crc-table is the vector returned
by crc:make-table.
If the implementation does not support deg-bit integers, then
crc:make-table returns #f.
Computes the P1003.2/D11.2 (POSIX.2) 32-bit checksum of file.
(require 'crc) (cksum (in-vicinity (library-vicinity) "ratize.scm")) => 157103930
cksum-string, which returns the P1003.2/D11.2 (POSIX.2) 32-bit
checksum of the bytes in str, can be defined as follows:
(require 'string-port) (define (cksum-string str) (call-with-input-string str cksum))
Computes the USB data-packet (16-bit) CRC of file.
crc16 calculates the same values as the crc16.pl program given
in http://www.usb.org/developers/data/crcdes.pdf.
Computes the USB token (5-bit) CRC of file.
crc5 calculates the same values as the crc5.pl program given
in http://www.usb.org/developers/data/crcdes.pdf.
The default value for charplot:dimensions is the
output-port-height and output-port-width of
current-output-port.
Example:
(require 'charplot)
(set! charplot:dimensions '(20 55))
(define (make-points n)
(if (zero? n)
'()
(cons (list (/ n 6) (sin (/ n 6))) (make-points (1- n)))))
(plot (make-points 40) "x" "Sin(x)")
-|
Sin(x) _________________________________________
1|- **** |
| ** ** |
0.75|- * * |
| * * |
0.5|- * * |
| * *|
0.25|- * * |
| * * |
0|-------------------*------------------*--|
| * |
-0.25|- * * |
| * * |
-0.5|- * |
| * * |
-0.75|- * * |
| ** ** |
-1|- **** |
|:_____._____:_____._____:_____._____:____|
x 2 4 6
(plot sin 0 (* 2 pi))
-|
_________________________________________
1|-: **** |
| : ** ** |
0.75|-: * * |
| : * * |
0.5|-: ** ** |
| : * * |
0.25|-:** ** |
| :* * |
0|-*------------------*--------------------|
| : * * |
-0.25|-: ** ** |
| : * * |
-0.5|-: * ** |
| : * * |
-0.75|-: * ** |
| : ** ** |
-1|-: **** |
|_:_____._____:_____._____:_____._____:___|
0 2 4 6
(require 'random-inexact)
(histograph (do ((idx 99 (+ -1 idx))
(lst '() (cons (* .02 (random:normal)) lst)))
((negative? idx) lst))
"normal")
-|
_________________________________________
8|- : I |
| : I |
7|- I I : I |
| I I : I |
6|- III I :I I |
| III I :I I |
5|- IIIIIIIIII I |
| IIIIIIIIII I |
4|- IIIIIIIIIIII |
| IIIIIIIIIIII |
3|-I I I IIIIIIIIIIII II I |
| I I I IIIIIIIIIIII II I |
2|-I I I IIIIIIIIIIIIIIIII I |
| I I I IIIIIIIIIIIIIIIII I |
1|-II I I IIIIIIIIIIIIIIIIIIIII I I I |
| II I I IIIIIIIIIIIIIIIIIIIII I I I |
0|-IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII----|
|__.____:____.____:____.____:____.____:___|
normal -0.025 0 0.025 0.05
(require 'eps-graph)
This is a graphing package creating encapsulated-PostScript files. Its motivations and design choice are described in http://swiss.csail.mit.edu/~jaffer/Docupage/grapheps
A dataset to be plotted is taken from a 2-dimensional array. Corresponding coordinates are in rows. Coordinates from any pair of columns can be plotted.
filename.eps should be a string naming an output file to be created. size should be an exact integer, a list of two exact integers, or #f. elt1, ... are values returned by graphing primitives described here.
create-postscript-graph creates an Encapsulated-PostScript file named filename.eps containing
graphs as directed by the elt1, ... arguments.
The size of the graph is determined by the size argument. If a list of two integers, they specify the width and height. If one integer, then that integer is the width and the height is 3/4 of the width. If #f, the graph will be 800 by 600.
These graphing procedures should be called as arguments to
create-postscript-graph. The order of these arguments is
significant; PostScript graphics state is affected serially from the
first elt argument to the last.
Pushes a rectangle for the whole encapsulated page onto the
PostScript stack. This pushed rectangle is an implicit argument to
partition-page or setup-plot.
A range is a list of two numbers, the minimum and the maximum.
Ranges can be given explicity or computed in PostScript by
column-range.
Returns the range of values in 2-dimensional array column k.
Expands range by p/100 on each end.
Expands range to round number of ticks.
Returns the minimal range covering all range1, range2, ...
pad-range, snap-range, or combine-range.
pagerect is the rectangle bounding the graph to be drawn; if missing, the
rectangle from the top of the PostScript stack is popped and used.
Based on the given ranges, setup-plot sets up scaling and margins for making
a graph. The margins are sized proportional to the fontheight
value at the time of the call to setup-plot. setup-plot sets two variables:
setup-plot. Includes plotrect, legends, etc.
Plots points with x coordinate in x-column of array and y coordinate y-column of array. The symbol proc3s specifies the type of glyph or drawing style for presenting these coordinates.
The glyphs and drawing styles available are:
line
mountain
cloud
impulse
bargraph
disc
point
square
diamond
plus
cross
triup
tridown
pentagon
circle
Saves the current graphics state, executes args, then restores to saved graphics state.
color should be a string naming a Resene color, a saturate color, or a number between 0 and 100.
set-color sets the PostScript color to the color of the given string, or a
grey value between black (0) and white (100).
name should be a (case-sensitive) string naming a PostScript font. fontheight should be a positive real number.
set-font Changes the current PostScript font to name with height equal to
fontheight. The default font is Helvetica (12pt).
The base set of PostScript fonts is:
| Times | Times-Italic | Times-Bold | Times-BoldItalic |
| Helvetica | Helvetica-Oblique | Helvetica-Bold | Helvetica-BoldOblique |
| Courier | Courier-Oblique | Courier-Bold | Courier-BoldOblique |
| Symbol |
Line parameters do no affect fonts; they do effect glyphs.
The default linewidth is 1. Setting it to 0 makes the lines drawn as skinny as possible. Linewidth must be much smaller than glyphsize for readable glyphs.
Lines are drawn j-on k-off.
Sets the (PostScript) variable glyphsize to w. The default glyphsize is 6.
The effects of clip-to-rect are also part of the graphic
context.
A rectangle is a list of 4 numbers; the first two elements are the x and y coordinates of lower left corner of the rectangle. The other two elements are the width and height of the rectangle.
Pushes a rectangle for the whole encapsulated page onto the
PostScript stack. This pushed rectangle is an implicit argument to
partition-page or setup-plot.
Pops the rectangle currently on top of the stack and pushes xparts * yparts
sub-rectangles onto the stack in decreasing y and increasing x order.
If you are drawing just one graph, then you don't need partition-page.
The rectangle where data points should be plotted. plotrect is set by
setup-plot.
The pagerect argument of the most recent call to
setup-plot. Includes plotrect, legends, etc.
fills rect with the current color.
Draws the perimiter of rect in the current color.
Modifies the current graphics-state so that nothing will be drawn
outside of the rectangle rect. Use in-graphic-context to limit
the extent of clip-to-rect.
graphrect.
graphrect.
These edge coordinates of graphrect are suitable for passing
as the first argument to rule-horizontal.
These edge coordinates of graphrect are suitable for passing
as the first argument to rule-vertical.
The margin-templates are strings whose displayed width is used to reserve space for the left and right side numerical legends. The default values are "-.0123456789".
Draws a vertical ruler with X coordinate x-coord and labeled with string text. If tick-width is positive, then the ticks are tick-width long on the right side of x-coord; and text and numeric legends are on the left. If tick-width is negative, then the ticks are -tick-width long on the left side of x-coord; and text and numeric legends are on the right.
Draws a horizontal ruler with Y coordinate y-coord and labeled with string text. If tick-height is positive, then the ticks are tick-height long on the top side of y-coord; and text and numeric legends are on the bottom. If tick-height is negative, then the ticks are -tick-height long on the bottom side of y-coord; and text and numeric legends are on the top.
Draws the y-axis.
Draws the x-axis.
Draws vertical lines through graphrect at each tick on the
vertical ruler.
Draws horizontal lines through graphrect at each tick on the
horizontal ruler.
A list of the width and height of the graph to be plotted using
plot.
(system "gv tmp.eps") an
encapsulated PostScript graph of the function of one argument func
over the range x1 to x2. If the optional integer argument npts is
supplied, it specifies the number of points to evaluate func at.
The file `am1.5.html', a table of solar irradiance, is fetched with `wget' if it isn't already in the working directory. The file is read and stored into an array, irradiance.
create-postscript-graph is then called to create an
encapsulated-PostScript file, `solarad.eps'. The size of the
page is set to 600 by 300. whole-page is called and leaves
the rectangle on the PostScript stack. setup-plot is called
with a literal range for x and computes the range for column 1.
Two calls to top-title are made so a different font can be
used for the lower half. in-graphic-context is used to limit
the scope of the font change. The graphing area is outlined and a
rule drawn on the left side.
Because the X range was intentionally reduced,
in-graphic-context is called and clip-to-rect limits
drawing to the plotting area. A black line is drawn from data
column 1. That line is then overlayed with a mountain plot of the
same column colored "Bright Sun".
After returning from the in-graphic-context, the bottom ruler
is drawn. Had it been drawn earlier, all its ticks would have been
painted over by the mountain plot.
The color is then changed to `seagreen' and the same graphrect is setup again, this time with a different Y scale, 0 to 1000. The graphic context is again clipped to plotrect, linedash is set, and column 2 is plotted as a dashed line. Finally the rightedge is ruled. Having the line and its scale both in green helps disambiguate the scales.
(require 'eps-graph)
(require 'line-i/o)
(require 'string-port)
(define irradiance
(let ((url "http://www.pv.unsw.edu.au/am1.5.html")
(file "am1.5.html"))
(define (read->list line)
(define elts '())
(call-with-input-string line
(lambda (iprt) (do ((elt (read iprt) (read iprt)))
((eof-object? elt) elts)
(set! elts (cons elt elts))))))
(if (not (file-exists? file))
(system (string-append "wget -c -O" file " " url)))
(call-with-input-file file
(lambda (iprt)
(define lines '())
(do ((line (read-line iprt) (read-line iprt)))
((eof-object? line)
(let ((nra (make-array (A:floR64b)
(length lines)
(length (car lines)))))
(do ((lns lines (cdr lns))
(idx (+ -1 (length lines)) (+ -1 idx)))
((null? lns) nra)
(do ((kdx (+ -1 (length (car lines))) (+ -1 kdx))
(lst (car lns) (cdr lst)))
((null? lst))
(array-set! nra (car lst) idx kdx)))))
(if (and (positive? (string-length line))
(char-numeric? (string-ref line 0)))
(set! lines (cons (read->list line) lines))))))))
(let ((xrange '(.25 2.5)))
(create-postscript-graph
"solarad.eps" '(600 300)
(whole-page)
(setup-plot xrange (column-range irradiance 1))
(title-top
"Solar Irradiance http://www.pv.unsw.edu.au/am1.5.html")
(in-graphic-context
(set-font "Helvetica-Oblique" 12)
(title-top
""
"Key Centre for Photovoltaic Engineering UNSW - Air Mass 1.5 Global Spectrum"))
(outline-rect plotrect)
(rule-vertical leftedge "W/(m^2.um)" 10)
(in-graphic-context (clip-to-rect plotrect)
(plot-column irradiance 0 1 'line)
(set-color "Bright Sun")
(plot-column irradiance 0 1 'mountain)
)
(rule-horizontal bottomedge "Wavelength in .um" 5)
(set-color 'seagreen)
(setup-plot xrange '(0 1000) graphrect)
(in-graphic-context (clip-to-rect plotrect)
(set-linedash 5 2)
(plot-column irradiance 0 2 'line))
(rule-vertical rightedge "Integrated .W/(m^2)" -10)
))
(system "gv solarad.eps")
http://swiss.csail.mit.edu/~jaffer/Solid/#Example gives an example use of this package.
VRML97 strings passed to vrml and vrml-to-file as
arguments will appear in the resulting VRML code. This string turns
off the headlight at the viewpoint:
" NavigationInfo {headlight FALSE}"
colors is a list of color objects. Each may be of type section Color Data-Type, a 24-bit sRGB integer, or a list of 3 numbers between 0.0 and 1.0.
angles is a list of non-increasing angles the same length as colors. Each angle is between 90 and -90 degrees. If 90 or -90 are not elements of angles, then the color at the zenith and nadir are taken from the colors paired with the angles nearest them.
scene:sphere fills horizontal bands with interpolated colors on the background
sphere encasing the world.
latitude is the virtual place's latitude in degrees. julian-day is an integer from 0 to 366, the day of the year. hour is a real number from 0 to 24 for the time of day; 12 is noon. turbidity is the degree of fogginess described in See section Daylight.
scene:sun returns a bright yellow, distant sphere where the sun would be at
hour on julian-day at latitude. If strength is positive, included is a light source of strength
(default 1).
latitude is the virtual place's latitude in degrees. julian-day is an integer from 0 to 366, the day of the year. hour is a real number from 0 to 24 for the time of day; 12 is noon. turbidity is the degree of cloudiness described in See section Daylight.
scene:overcast returns an overcast sky as it might look at hour on julian-day at latitude. If strength
is positive, included is an ambient light source of strength (default 1).
Viewpoints are objects in the virtual world, and can be transformed individually or with solid objects.
In VRML97, lights shine only on objects within the same children node
and descendants of that node. Although it would have been convenient
to let light direction be rotated by solid:rotation, this
restricts a rotated light's visibility to objects rotated with it.
To workaround this limitation, these directional light source
procedures accept either Cartesian or spherical coordinates for
direction. A spherical coordinate is a list (theta
azimuth); where theta is the angle in degrees from the
zenith, and azimuth is the angle in degrees due west of south.
It is sometimes useful for light sources to be brighter than `1'. When intensity arguments are greater than 1, these functions gang multiple sources to reach the desired strength.
color is a an object of type section Color Data-Type, a 24-bit sRGB integer, or a list of 3 numbers between 0.0 and 1.0. If color is #f, then the default color will be used. intensity is a real non-negative number defaulting to `1'.
light:ambient returns a light source or sources of color with total strength of intensity
(or 1 if omitted).
color is a an object of type section Color Data-Type, a 24-bit sRGB integer, or a list of 3 numbers between 0.0 and 1.0. If color is #f, then the default color will be used.
direction must be a list or vector of 2 or 3 numbers specifying the direction to this light. If direction has 2 numbers, then these numbers are the angle from zenith and the azimuth in degrees; if direction has 3 numbers, then these are taken as a Cartesian vector specifying the direction to the light source. The default direction is upwards; thus its light will shine down.
intensity is a real non-negative number defaulting to `1'.
light:directional returns a light source or sources of color with total strength of intensity,
shining from direction.
attenuation is a list or vector of three nonnegative real numbers specifying the reduction of intensity, the reduction of intensity with distance, and the reduction of intensity as the square of distance. radius is the distance beyond which the light does not shine. radius defaults to `100'.
aperture is a real number between 0 and 180, the angle centered on the light's axis through which it sheds some light. peak is a real number between 0 and 90, the angle of greatest illumination.
Point light radiates from location, intensity decreasing with distance, towards all objects with which it is grouped.
color is a an object of type section Color Data-Type, a 24-bit sRGB
integer, or a list of 3 numbers between 0.0 and 1.0. If color is #f,
then the default color will be used. intensity is a real non-negative number
defaulting to `1'. beam is a structure returned by
light:beam or #f.
light:point returns a light source or sources at location of color with total strength
intensity and beam properties. Note that the pointlight itself is not visible.
To make it so, place an object with emissive appearance at location.
Spot light radiates from location towards direction, intensity decreasing with distance, illuminating objects with which it is grouped.
direction must be a list or vector of 2 or 3 numbers specifying the direction to this light. If direction has 2 numbers, then these numbers are the angle from zenith and the azimuth in degrees; if direction has 3 numbers, then these are taken as a Cartesian vector specifying the direction to the light source. The default direction is upwards; thus its light will shine down.
color is a an object of type section Color Data-Type, a 24-bit sRGB integer, or a list of 3 numbers between 0.0 and 1.0. If color is #f, then the default color will be used.
intensity is a real non-negative number defaulting to `1'.
light:spot returns a light source or sources at location of direction with total strength
color. Note that the spotlight itself is not visible. To make it so,
place an object with emissive appearance at location.
solid:box returns a cube with sides of length geometry centered on the
origin. Otherwise, solid:box returns a rectangular box with dimensions geometry
centered on the origin. appearance determines the surface properties of the
returned object.
Returns a box of the specified geometry, but with the y-axis of a texture specified in appearance being applied along the longest dimension in geometry.
(abs radius) and (abs height)
centered on the origin. If height is positive, then the cylinder ends
will be capped. If radius is negative, then only the ends will appear.
appearance determines the surface properties of the returned
object.
solid:disk returns a circular disk
with dimensions radius and thickness centered on the origin. appearance determines the
surface properties of the returned object.
solid:ellipsoid returns a sphere of diameter geometry centered on the origin.
Otherwise, solid:ellipsoid returns an ellipsoid with diameters geometry centered on the
origin. appearance determines the surface properties of the returned object.
solid:polyline returns lines
connecting successive pairs of points. If called with one argument,
then the polyline will be white. If appearance is given, then the polyline
will have its emissive color only; being black if appearance does not have
an emissive color.
The following code will return a red line between points at
(1 2 3) and (4 5 6):
(solid:polyline '((1 2 3) (4 5 6)) (solid:color #f 0 #f 0 '(1 0 0)))
solid:prism will
close the sequence if the first and last coordinates are not the
same.
solid:prism returns a capped prism y long.
solid:basrelief returns a width by depth basrelief solid with heights per array height with
the buttom surface centered on the origin.
If present, appearance determines the surface properties of the returned object. If present, colorray must be an array of objects of type section Color Data-Type, 24-bit sRGB integers or lists of 3 numbers between 0.0 and 1.0.
If colorray's dimensions match height, then each element of colorray paints its corresponding vertex of height. If colorray has all dimensions one smaller than height, then each element of colorray paints the corresponding face of height. Other dimensions for colorray are in error.
fontstyle must be a value returned by solid:font.
str must be a string or list of strings.
len must be #f, a nonnegative integer, or list of nonnegative integers.
appearance, if given, determines the surface properties of the returned object.
solid:text returns a two-sided, flat text object positioned in the Z=0 plane
of the local coordinate system
Returns an appearance, the optical properties of the objects with which it is associated. ambientIntensity, shininess, and transparency must be numbers between 0 and 1. diffuseColor, specularColor, and emissiveColor are objects of type section Color Data-Type, 24-bit sRGB integers or lists of 3 numbers between 0.0 and 1.0. If a color argument is omitted or #f, then the default color will be used.
Returns an appearance, the optical properties of the objects
with which it is associated. image is a string naming a JPEG or PNG
image resource. color is #f, a color, or the string returned by
solid:color. The rest of the optional arguments specify
2-dimensional transforms applying to the image.
scale must be #f, a number, or list or vector of 2 numbers specifying the scale to apply to image. rotation must be #f or the number of degrees to rotate image. center must be #f or a list or vector of 2 numbers specifying the center of image relative to the image dimensions. translation must be #f or a list or vector of 2 numbers specifying the translation to apply to image.
Returns a fontstyle object suitable for passing as an argument to
solid:text. Any of the arguments may be #f, in which case
its default value, which is first in each list of allowed values, is
used.
family is a case-sensitive string naming a font; `SERIF', `SANS', and `TYPEWRITER' are supported at the minimum.
style is a case-sensitive string `PLAIN', `BOLD', `ITALIC', or `BOLDITALIC'.
justify is a case-sensitive string `FIRST', `BEGIN', `MIDDLE', or `END'; or a list of one or two case-sensitive strings (same choices). The mechanics of justify get complicated; it is explained by tables 6.2 to 6.7 of http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-IS-VRML97WithAmendment1/part1/nodesRef.html#Table6.2
size is the extent, in the non-advancing direction, of the text. size defaults to 1.
spacing is the ratio of the line (or column) offset to size. spacing defaults to 1.
language is the RFC-1766 language name.
direction is a list of two numbers: (x y). If
(> (abs x) (abs y)), then the text will be
arrayed horizontally; otherwise vertically. The direction in which
characters are arrayed is determined by the sign of the major axis:
positive x being left-to-right; positive y being
top-to-bottom.
center must be a list or vector of three numbers. Returns an upward pointing metallic arrow centered at center.
solid:translation Returns an
aggregate of solids, ... with their origin moved to center.
solid:scale
Returns an aggregate of solids, ... scaled per scale.
solid:rotation Returns an
aggregate of solids, ... rotated angle degrees around the axis axis.
http://swiss.csail.mit.edu/~jaffer/Color
The goals of this package are to provide methods to specify, compute, and transform colors in a core set of additive color spaces. The color spaces supported should be sufficient for working with the color data encountered in practice and the literature.
CIEXYZ, RGB709, and
sRGB, the sole arg is a list of three numbers.
L*a*b*, L*u*v*, and
L*C*h, arg is a list of three numbers optionally followed
by a whitepoint.
xRGB, arg is an integer.
e-sRGB, the arguments are as for e-sRGB->color.
color-precision returns the
number of bits used for each of the R, G, and B channels of the
encoding. Otherwise, color-precision returns #f
Each color encoding has an external, case-insensitive representation. To ensure portability, the white-point for all color strings is D65. (5)
| Color Space | External Representation |
| CIEXYZ | CIEXYZ:<X>/<Y>/<Z> |
| RGB709 | RGBi:<R>/<G>/<B> |
| L*a*b* | CIELAB:<L>/<a>/<b> |
| L*u*v* | CIELuv:<L>/<u>/<v> |
| L*C*h | CIELCh:<L>/<C>/<h> |
The X, Y, Z, L, a, b, u, v, C, h, R, G, and B fields are (Scheme) real numbers within the appropriate ranges.
| Color Space | External Representation |
| sRGB | sRGB:<R>/<G>/<B> |
| e-sRGB10 | e-sRGB10:<R>/<G>/<B> |
| e-sRGB12 | e-sRGB12:<R>/<G>/<B> |
| e-sRGB16 | e-sRGB16:<R>/<G>/<B> |
The R, G, and B, fields are non-negative exact decimal integers within the appropriate ranges.
Several additional syntaxes are supported by string->color:
| Color Space | External Representation |
| sRGB | sRGB:<RRGGBB> |
| sRGB | #<RRGGBB> |
| sRGB | 0x<RRGGBB> |
| sRGB | #x<RRGGBB> |
Where RRGGBB is a non-negative six-digit hexadecimal number.
string->color
returns #f.
We experience color relative to the illumination around us. CIEXYZ coordinates, although subject to uniform scaling, are objective. Thus other color spaces are specified relative to a white point in CIEXYZ coordinates.
The white point for digital color spaces is set to D65. For the other spaces a white-point argument can be specified. The default if none is specified is the white-point with which the color was created or last converted; and D65 if none has been specified.
Measurement-based Color Spaces
The tristimulus color spaces are those whose component values are proportional measurements of light intensity. The CIEXYZ(1931) system provides 3 sets of spectra to dot-product with a spectrum of interest. The result of those dot-products is coordinates in CIEXYZ space. All tristimuls color spaces are related to CIEXYZ by linear transforms, namely matrix multiplication. Of the color spaces listed here, CIEXYZ and RGB709 are tristimulus spaces.
CIEXYZ is a list of three inexact numbers between 0.0 and 1.1. '(0. 0. 0.) is black; '(1. 1. 1.) is white.
xyz must be a list of 3 numbers. If xyz is valid CIEXYZ coordinates,
then ciexyz->color returns the color specified by xyz; otherwise returns #f.
Returns the CIEXYZ color composed of x, y, z. If the coordinates do not encode a valid CIEXYZ color, then an error is signaled.
An RGB709 color is represented by a list of three inexact numbers between 0.0 and 1.0. '(0. 0. 0.) is black '(1. 1. 1.) is white.
rgb must be a list of 3 numbers. If rgb is valid RGB709 coordinates,
then rgb709->color returns the color specified by rgb; otherwise returns #f.
Returns the RGB709 color composed of r, g, b. If the coordinates do not encode a valid RGB709 color, then an error is signaled.
Although properly encoding the chromaticity, tristimulus spaces do not match the logarithmic response of human visual systems to intensity. Minimum detectable differences between colors correspond to a smaller range of distances (6:1) in the L*a*b* and L*u*v* spaces than in tristimulus spaces (80:1). For this reason, color distances are computed in L*a*b* (or L*C*h).
L*a*b* must be a list of 3 numbers. If L*a*b* is valid L*a*b* coordinates,
then l*a*b*->color returns the color specified by L*a*b*; otherwise returns #f.
Returns the L*a*b* color composed of L*, a*, b* with white-point.
Returns the list of 3 numbers encoding color in L*a*b* with white-point.
L*u*v* must be a list of 3 numbers. If L*u*v* is valid L*u*v* coordinates,
then l*u*v*->color returns the color specified by L*u*v*; otherwise returns #f.
Returns the L*u*v* color composed of L*, u*, v* with white-point.
Returns the list of 3 numbers encoding color in L*u*v* with white-point.
HSL (Hue Saturation Lightness), HSV (Hue Saturation Value), HSI (Hue Saturation Intensity) and HCI (Hue Chroma Intensity) are cylindrical color spaces (with angle hue). But these spaces are all defined in terms device-dependent RGB spaces.
One might wonder if there is some fundamental reason why intuitive specification of color must be device-dependent. But take heart! A cylindrical system can be based on L*a*b* and is used for predicting how close colors seem to observers.
The colors by quadrant of h are:
| 0 | red, orange, yellow | 90 |
| 90 | yellow, yellow-green, green | 180 |
| 180 | green, cyan (blue-green), blue | 270 |
| 270 | blue, purple, magenta | 360 |
L*C*h must be a list of 3 numbers. If L*C*h is valid L*C*h coordinates,
then l*c*h->color returns the color specified by L*C*h; otherwise returns #f.
Returns the L*C*h color composed of L*, C*, h with white-point.
Returns the list of 3 numbers encoding color in L*C*h with white-point.
The color spaces discussed so far are impractical for image data because of numerical precision and computational requirements. In 1998 the IEC adopted A Standard Default Color Space for the Internet - sRGB (http://www.w3.org/Graphics/Color/sRGB). sRGB was cleverly designed to employ the 24-bit (256x256x256) color encoding already in widespread use; and the 2.2 gamma intrinsic to CRT monitors.
Conversion from CIEXYZ to digital (sRGB) color spaces is accomplished by conversion first to a RGB709 tristimulus space with D65 white-point; then each coordinate is individually subjected to the same non-linear mapping. Inverse operations in the reverse order create the inverse transform.
rgb must be a list of 3 numbers. If rgb is valid sRGB coordinates,
then srgb->color returns the color specified by rgb; otherwise returns #f.
Returns the sRGB color composed of r, g, b. If the coordinates do not encode a valid sRGB color, then an error is signaled.
Returns the list of 3 integers encoding color in sRGB.
Returns the sRGB color composed of the 24-bit integer k.
A triplet of integers represent e-sRGB colors. Three precisions are supported:
e-srgb->color returns the color
specified by rgb; otherwise returns #f.
Returns the e-sRGB10 color composed of integers r, g, b.
color->e-srgb returns the list of 3
integers encoding color in sRGB10, sRGB12, or sRGB16.
The following functions compute colors from spectra, scale color luminance, and extract chromaticity. XYZ is used in the names of procedures for unnormalized colors; the coordinates of CIEXYZ colors are constrained as described in section Color Spaces.
(require 'color-space)
A spectrum may be represented as:
CIEXYZ values are calculated as dot-product with the X, Y (Luminance), and Z Spectral Tristimulus Values. The files `cie1931.xyz' and `cie1964.xyz' in the distribution contain these CIE-defined values.
(require 'cie1964) or (require 'cie1931) will
load-ciexyz specific values used by the following spectrum
conversion procedures. The spectrum conversion procedures
(require 'ciexyz) to assure that a set is loaded.
read-cie-illuminant
reads (using Scheme read) these numbers and returns a length
107 vector filled with them.
(define CIE:SI-D65 (read-CIE-illuminant (in-vicinity (library-vicinity) "ciesid65.dat"))) (spectrum->XYZ CIE:SI-D65 300e-9 830e-9) => (25.108569422374994 26.418013465625001 28.764075683374993)
read-normalized-illuminant reads (using Scheme read)
these numbers and returns a length 107 vector filled with them,
normalized so that spectrum->XYZ of the illuminant returns its
whitepoint.
CIE Standard Illuminants A and D65 are included with SLIB:
(define CIE:SI-A (read-normalized-illuminant (in-vicinity (library-vicinity) "ciesia.dat"))) (define CIE:SI-D65 (read-normalized-illuminant (in-vicinity (library-vicinity) "ciesid65.dat"))) (spectrum->XYZ CIE:SI-A 300e-9 830e-9) => (1.098499460820401 999.9999999999998e-3 355.8173930654951e-3) (CIEXYZ->sRGB (spectrum->XYZ CIE:SI-A 300e-9 830e-9)) => (255 234 133) (spectrum->XYZ CIE:SI-D65 300e-9 830e-9) => (950.4336673552745e-3 1.0000000000000002 1.0888053986649182) (CIEXYZ->sRGB (spectrum->XYZ CIE:SI-D65 300e-9 830e-9)) => (255 255 255)
illuminant-map returns a vector of length 107 containing the
result of applying proc to each element of siv.
(spectrum->XYZ (illuminant-map proc siv) 300e-9 830e-9)
spectrum->XYZ
computes the CIEXYZ(1931) values for the spectrum returned by proc
when called with arguments from 380e-9 to 780e-9, the wavelength in
meters.
spectrum->XYZ returns the
CIEXYZ(1931) values for a light source with spectral values proportional
to the elements of spectrum at evenly spaced wavelengths between
x1 and x2.
Compute the colors of 6500.K and 5000.K blackbody radiation:
(require 'color-space)
(define xyz (spectrum->XYZ (blackbody-spectrum 6500)))
(define y_n (cadr xyz))
(map (lambda (x) (/ x y_n)) xyz)
=> (0.9687111145512467 1.0 1.1210875945303613)
(define xyz (spectrum->XYZ (blackbody-spectrum 5000)))
(map (lambda (x) (/ x y_n)) xyz)
=> (0.2933441826889158 0.2988931825387761 0.25783646831201573)
wavelength->XYZ returns (unnormalized) XYZ values for a
monochromatic light source with wavelength w.
wavelength->chromaticity returns the chromaticity for a
monochromatic light source with wavelength w.
The optional argument span is the wavelength analog of bandwidth. With the default span of 1.nm (1e-9.m), the values returned by the procedure correspond to the power of the photons with wavelengths w to w+1e-9.
temperature->XYZ computes the unnormalized CIEXYZ(1931) values
for the spectrum of a black body at temperature x.
Compute the chromaticities of 6500.K and 5000.K blackbody radiation:
(require 'color-space)
(XYZ->chromaticity (temperature->XYZ 6500))
=> (0.3135191660557008 0.3236456786200268)
(XYZ->chromaticity (temperature->XYZ 5000))
=> (0.34508082841161052 0.3516084965163377)
temperature->cromaticity computes the chromaticity for the
spectrum of a black body at temperature x.
Compute the chromaticities of 6500.K and 5000.K blackbody radiation:
(require 'color-space)
(temperature->chromaticity 6500)
=> (0.3135191660557008 0.3236456786200268)
(temperature->chromaticity 5000)
=> (0.34508082841161052 0.3516084965163377)
Many color datasets are expressed in xyY format; chromaticity with CIE luminance (Y). But xyY is not a CIE standard like CIEXYZ, CIELAB, and CIELUV. Although chrominance is well defined, the luminance component is sometimes scaled to 1, sometimes to 100, but usually has no obvious range. With no given whitepoint, the only reasonable course is to ascertain the luminance range of a dataset and normalize the values to lie from 0 to 1.
xyY:normalize-colors
scales each chromaticity so it sums to 1 or less; and divides the
Y values by the maximum Y in the dataset, so all lie between
0 and 1.
xyY:normalize-colors divides
the Y values by n times the maximum Y in the dataset.
If n is an exact non-positive integer, then
xyY:normalize-colors divides the Y values by the maximum of
the Ys in the dataset excepting the -n largest Y
values.
In all cases, returned Y values are limited to lie from 0 to 1.
Why would one want to normalize to other than 1? If the sun or its reflection is the brightest object in a scene, then normalizing to its luminance will tend to make the rest of the scene very dark. As with photographs, limiting the specular highlights looks better than darkening everything else.
The results of measurements being what they are,
xyY:normalize-colors is extremely tolerant. Negative numbers are
replaced with zero, and chromaticities with sums greater than one are
scaled to sum to one.
(require 'color-space)
The low-level metric functions operate on lists of 3 numbers, lab1, lab2, lch1, or lch2.
(require 'color)
The wrapped functions operate on objects of type color, color1 and color2 in the function entries.
Measures distance in the L*C*h cylindrical color-space. The three axes are individually scaled (depending on C*) in their contributions to the total distance.
The CIE has defined reference conditions under which the metric with default parameters can be expected to perform well. These are:
The parametric-factors argument is a list of 3 quantities kL, kC and kH. parametric-factors independently adjust each colour-difference term to account for any deviations from the reference viewing conditions. Under the reference conditions explained above, the default is kL = kC = kH = 1.
The Color Measurement Committee of The Society of Dyers and Colorists in Great Britain created a more sophisticated color-distance function for use in judging the consistency of dye lots. With CMC:DE* it is possible to use a single value pass/fail tolerance for all shades.
CMC:DE is a L*C*h metric. The parametric-factors
argument is a list of 2 numbers l and c. l and
c parameterize this metric. 1 and 1 are recommended for
perceptibility; the default, 2 and 1, for acceptability.
This package contains the low-level color conversion and color metric routines operating on lists of 3 numbers. There is no type or range checking.
(require 'color-space)
Do not convert e-sRGB precision through e-sRGB->sRGB then
sRGB->e-sRGB -- values would be truncated to 8-bits!
e-sRGB->e-sRGB converts srgb to e-sRGB of precision
n2.
Rather than ballast the color dictionaries with numbered grays,
file->color-dictionary discards them. They are provided
through the grey procedure:
Returns (inexact->exact (round (* k 2.55))), the X11 color
grey<k>.
A color dictionary is a database table relating canonical color-names to color-strings (see section Color Data-Type).
The column names in a color dictionary are unimportant; the first field is the key, and the second is the color-string.