You are looking at historical revision 44300 of this page. It may differ significantly from its current revision.

math-utils

Documentation

Miscellaneous Math Functions

Usage

 
(import math-utils)

fppred

fpsucc

[procedure] (fppred F [N]) -> float
[procedure] (fpsucc F [N]) -> float

Returns the Nth predecessor or successor of a floating-point number.

F
float : inexact point ;
N
integer : distance to move point ; default 1

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

slope

[procedure] (slope P1|X1 P2|Y1 [X2 Y2]) -> number

Slope of a line defined by 2 points, P1 & P2 or X1 Y1 & X2 Y2.

P1 & P2
(pair number number)
X1 Y1 & X2 Y2
number number

delta-slope

[procedure] (slope DX DY) -> number

Slope of a line delta.

DX}
number ; change in x
DY
number ; change in y

fxrnd

[procedure] (fxrnd [LIMIT]) -> fixnum

Return a random fixnum in the range [0 LIMIT).

LIMIT}
fixnum ; default most-positive-fixnum

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.9.0
Add fxrnd.
1.8.0
Add slope & delta-slope.
1.7.1
Use union for type pun.
1.7.0
Add euclidian-distances & manhattan-distances, add fppred && fpsucc, add @prec.
1.6.0
Add ~=, vector-scale, vector-shift, normalize-vector-scale, normalize-vector-shift.
1.5.3
factorial+-/memo.
1.5.2
Fix harmonic/memo.
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.