• Wiki
• Download
• Manual
• Eggs
• API
• Tests
• Bugs

• egg

math-utils

Documentation

Miscellaneous Math Functions

Usage

(import math-utils)

log-with-base

log/base

[procedure] (log-with-base B) -> (real -> real)
[procedure] (log/base B) -> (real -> real)

Returns a function for the base B logarithm.

coprime?

[procedure] (coprime? M [N0 ...]) -> boolean

Are the integers M N0 ... coprime?

pairwise-coprime?

[procedure] (pairwise-coprime? M [N0 ...]) -> boolean

Are the pairs of integers in M N0 ... coprime?

fxcoprime?

[procedure] (fxcoprime? M N) -> boolean

Are the fixnums M N coprime?

(import (only (srfi 1) filter iota))
(import (only (math-utils) fxcoprime?))

(define (coprimes n)
  (filter (cut fxcoprime? n <>) (iota (- n 1) 1)) )

(import (only (streams derived) stream-range stream-filter))
(import (only (math-utils) fxcoprime?))

(define (coprime-numbers-stream n)
  (stream-filter (cut fxcoprime? n <>) (stream-range 1 n)) )

simple-interest

[procedure] (simple-interest RATE TIME [PRIN]) -> number

The accumulation function, the principle is assumed 1. Returns the simple interest for the RATE over TIME.

RATE

number ; interest rate

TIME

number ; time period to cover

PRIN

number ; principle, default 1

compound-interest

[procedure] (compound-interest RATE FREQ TIME [PRIN]) -> number

The accumulation function, the principle is assumed 1. Returns the compound interest for the RATE, applied with FREQ, over TIME.

RATE

number ; interest rate

FREQ

number ; compounding frequency

TIME

number ; time period to cover

PRIN

number ; principle, default 1

(compound-interest 0.043 4 6 1500)
;=> 1938.84 ;rounded to 2 places

fibonacci

*fibonacci

fibonacci/memo

*fibonacci/memo

[procedure] (fibonacci N) -> integer
[procedure] (*fibonacci N) -> integer
[procedure] (fibonacci/memo N) -> integer
[procedure] (*fibonacci/memo N) -> integer

Returns fibonacci of integer N.

fibonacci/approximate

[procedure] (fibonacci/approximate N) -> real

Returns an approximate fibonacci of integer N, with an error of > 1 at N ~= 70.

binomial

[procedure] (binomial N1 N2) -> integer

Returns the Binomial in N1 to N2.

N1

integer

N2

integer

cross-ratio

[procedure] (cross-ratio N1 N2 N3 N4) -> number

Returns the Cross-ratio of N1, N2 and N3, N4.

N1

number

N2

number

N3

number

N4

number

~=

[procedure] (~= A B [EPSILON 1e-05]) -> boolean

Does A approximately equal B?

chinum

*chinum

[procedure] (chinum N) -> fixnum
[syntax] (*chinum N) -> fixnum

Returns 1 for even? and -1 for odd; (expt -1 N).

square

sqr

[procedure] (square N) -> number
[syntax] (sqr N) -> number

cube

cub

[procedure] (cube N) -> number
[syntax] (cub N) -> number

*average

[procedure] (*average LS) -> number

LS

(list-of number)

average

[procedure] (average [N0 ...]) -> number

N0

number

average*

[procedure] (average* [TREE ...]) -> number

TREE

(tree-of number)

least-squares

[procedure] (least-squares PNTS) -> number number

Returns b & e such that y ~= b * x + e.

PNTS

(list-of (pair number number)) : list of x,y pairs

trapezoid

[procedure] (trapezoid F N1 N2) -> (fixnum -> number)

Returns a function to calculate the area under F between N1 & N2 using the Trapezoid Rule. The function takes the number of estimations as an argument, larger for a "better" result.

F

(number -> number)

N1

number

N2

number

euclidian-distance

[procedure] (euclidian-distance X1 Y1 X2 Y2) -> number

X1 Y1

number number ; start point

X2 Y2

number number ; end point

manhattan-distance

[procedure] (manhattan-distance X1 Y1 X2 Y2) -> number

X1 Y1

number number ; start point

X2 Y2

number number ; end point

factorial

*factorial

factorial/memo

*factorial/memo

[procedure] (factorial N) -> integer
[procedure] (*factorial N) -> integer
[procedure] (factorial/memo N) -> integer
[procedure] (*factorial/memo N) -> integer

N

integer

factorial-

*factorial-

[procedure] (factorial- N FALL) -> real
[procedure] (*factorial- N FALL) -> real

The falling factorial.

N

real

FALL

integer

factorial+

*factorial+

[procedure] (factorial+ N RISE) -> real
[procedure] (*factorial+ N RISE) -> real

The rising factorial.

N

real

RISE

integer

harmonic

*harmonic

harmonic/memo

*harmonic/memo

[procedure] (harmonic N) -> real
[procedure] (*harmonic N) -> real

procedure>(harmonic/memo N) -> real</procedure> <procedure>(*harmonic/memo N) -> real</procedure>

Result of Harmonic series expansion to N terms.

N

integer

euclidian-distance

[procedure] (euclidian-distance X1 Y1 X2 Y2) -> number

Distance between X1,Y1 and X2,Y2.

X1 Y1

number number ; from point

X2 Y2

number number ; to point

manhattan-distance

[procedure] (manhattan-distance X1 Y1 X2 Y2) -> number

Distance between X1,Y1 and X2,Y2.

X1 Y1

number number ; from point

X2 Y2

number number ; to point

to-places

@prec

[syntax] (to-places PREC (FUNC EXPR))
[procedure] (@prec PREC EXPR [FUNC truncate])

Truncate the result of (FUNC EXPR) to PREC decimal places.

PREC

fixnum ; precision

FUNC

symbol ; clip operation, i.e. round, etc.

EXPR

* ; value to clip

big-pi

[syntax] (big-pi F N1 N2) -> number

Product of F in N1 to N2.

F

(number -> number) ;

N1

number ;

N2

number ;

big-sigma

[syntax] (big-sigma F N1 N2) -> number

Sum of F in N1 to N2.

F

(number -> number) ;

N1

number ;

N2

number ;

prod

[syntax] (prod VAR ([N1 [N2 [INC]]]) BODY...) -> number

Product of BODY... in N1 to N2 by INC.

VAR

symbol ; VAR bound to current N in BODY...

BODY...

number ;

N1

number ;

N2

number ;

INC

number ;

summ

[syntax] (summ VAR ([N1 [N2 [INC]]]) BODY...) -> number

Sum of BODY... in N1 to N2 by INC.

VAR

symbol ; VAR bound to current N in BODY...

BODY...

number ;

N1

number ;

N2

number ;

INC

number ;

Miscellaneous Vector Math Functions

Usage

(import (math-utils vector))

absolute-magnitude

[procedure] (absolute-magnitude NUMVEC) -> number

NUMVEC

(vector-of number) : .

cosine-similarity

[procedure] (cosine-similarity NUMVEC1 NUMVEC2) -> number

NUMVEC1

(vector-of number) : .

NUMVEC2

(vector-of number) : .

Must be same vector-length.

vector-compare

vector-compare2

[procedure] (vector-compare NUMVEC ...) -> number
[procedure] (vector-compare2 NUMVEC NUMVEC) -> number

Result is negative, zero, or positive. Comparison by length when unequal & element-wise when equal.

NUMVEC

(vector-of number) : .

dot-product

[procedure] (dot-product NUMVEC1 NUMVEC2) -> number

NUMVEC1

(vector-of number) : .

NUMVEC2

(vector-of number) : .

Must be same vector-length.

cross-product

[procedure] (cross-product NUMVEC1 NUMVEC2) -> (or number (vector-of number))

Only defined for a vector-length of (0 1 2 3 4 8). All others generate an error. Must be same vector-length.

NUMVEC1

(vector-of number) : .

NUMVEC2

(vector-of number) : .

vector-sum

[procedure] (vector-sum NUMVEC) -> number

softmax

[procedure] (softmax NUMVEC) -> (vector-of number)

Returns the softmax of the vector elements. Normalize the vector elements so (= 1 (vector-sum NUMVEC)).

softmax*

[procedure] (softmax* NUMVEC [TEMP]) -> (vector-of number)

Returns the softmax of the tempered vector elements. Spread, (< 1 TEMP), or shrink, (> 1 TEMP), data before normalization. A TEMP of 1 has no effect.

TEMP

real ; temperature, default 1.

Note that a TEMP near zero is currently an error!

vector-apply

[procedure] (vector-apply FUNC VEC1 VEC2 [VEC...]) -> vector

FUNC

(* * !#rest * -> *) : .

VEC#

vector : .

Must be same vector-length.

(import (only (math-utils vector) vector-apply))

(define (vector-mul . vs) (apply vector-apply * vs))
(define (vector-add . vs) (apply vector-apply + vs))
(define (vector-dif . vs) (apply vector-apply - vs))

vector-scale

vector-shift

[procedure] (vector-scale VEC FACTOR) -> vector
[procedure] (vector-shift VEC BIAS) -> vector

normalize-vector-scale

normalize-vector-shift

[procedure] (normalize-vector-scale VEC) -> vector
[procedure] (normalize-vector-shift VEC) -> vector

vector-scale by the (/ (vector-maximum)). vector-shift by the (- (vector-minimum)).

Examples

(import scheme)
(import (chicken base))
(import (rename (only math-utils
                  summ sqr
                  ;non-checking & memoized version is used
                  *chinum factorial/memo *factorial+/memo)
                (*chinum chinum)
                (factorial/memo factorial)
                (*factorial+/memo factorial+)))

;https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.132.221601
;@lam `lambda' param
(define (saha-sinha-pi #!optional (lim 100) (lam 4))
  (+ 4 (summ n (1 lim)
             (let* ((2n (* 2 n)) (2n+1 (+ 2n 1)))
               (* (/ 1 (factorial n))
                  (- (/ 1 (+ n lam)) (/ 4 2n+1))
                  (factorial+ (- (/ (sqr 2n+1) (+ (* 2 2n) (* 4 lam))) n)
                              (- n 1)))))) )

(define (madhava-leibniz-pi #!optional (lim 100))
  (* 4 (summ n (1 lim) (/ (chinum (- n 1)) (- (* 2 n) 1)))) )

(- (acos -1) (saha-sinha-pi))       ;=> 1.90993887372315e-11
(- (acos -1) (madhava-leibniz-pi))  ;=> -0.0101007524813226

Requirements

memoize miscmacros vector-lib

test test-utils

Author

Kon Lovett

Repository

This egg is hosted on the CHICKEN Subversion repository:

https://anonymous@code.call-cc.org/svn/chicken-eggs/release/5/math-utils

If you want to check out the source code repository of this egg and you are not familiar with Subversion, see this page.

Version history

1.6.0

Add ~=, vector-scale, vector-shift, normalize-vector-scale, normalize-vector-shift.

1.5.3

factorial+-/memo.

1.5.2

.

1.5.1

Add *average, average*. Fix signatures.

1.5.0

Add softmax*, chinum, *chinum, summ, prod, sqr, cub, *... (no type checks) & ../memo (memoized) series routines. Rename *fibonacci fibonacci/approximate

1.4.0

Add softmax. Allow real arguments to factorial+, factorial-, harmonic. Add euclidian-distance & manhattan-distance.

1.3.2

Fix cross-product return.

1.3.1

Fix average signature.

1.3.0

cross-product returns number-vector. Add vector-compare2. Rename fibonacci*. Drop deprecated.

1.2.0

Add to-places. Deprecate with-places.

1.1.0

Add with-places.

1.0.6

Remove mathh dependency since include is unreliable.

1.0.5

Use gcd based algorithm.

1.0.4

Add fxcoprime?.

1.0.3

*coprime? too slow.

1.0.2

Fix mathh dependency.

1.0.1

Add vector-compare.

1.0.0

From mathh:4.6.5.

License

This code is in the public domain.