math-utils

Documentation

Miscellaneous Math Functions

Usage

(import math-utils)

fppred

fpsucc

(fppred F [N]) -> float(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

(log-with-base B) -> (real -> real)(log/base B) -> (real -> real)

Returns a function for the base B logarithm.

degree->radian

radian->degree

(degree->radian N) -> real(radian->degree N) -> real

Convert between radians & degrees.

N: real

prime?

[procedure] (prime? N) -> boolean

Is N prime?

N: integer

primes

[procedure] (primes [N 2]) -> (-> integer)

Returns an infinite generator for the primes from N, which must be a prime.

(define (generate-primes n)
  (assert (integer? n)
          'generate-primes "bad argument type - not integer" n)
  (assert (not (negative? n))
          'generate-primes "bad argument type - not positive" n)
  (let ((i n)
        (ps (primes)) )
    (lambda ()
      (if (zero? i) #!eof
          (let ((p (ps)))
            (set! i (- i 1))
            p ) ) ) ) )

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

(fibonacci N) -> integer(*fibonacci N) -> integer(fibonacci/memo N) -> integer(*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

*binomial

binomial/memo

*binomial/memo

(binomial N K) -> integer(*binomial N K) -> integer(binomial/memo N K) -> integer(*binomial/memo N K) -> integer

Returns the number of combinations of length K in N.

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

(chinum N) -> fixnum(*chinum N) -> fixnum

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

square

sqr

(square N) -> number(sqr N) -> number

cube

cub

(cube N) -> number(cub N) -> number

minimum ((list-of number) -> number))

[procedure] (minimum LS) -> number

LS: (list-of number)

maximum ((list-of number) -> number))

[procedure] (maximum LS) -> number

LS: (list-of number)

range-value ((list-of number) -> number))

[procedure] (range-value LS) -> number

LS: (list-of 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

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

(factorial N) -> integer(*factorial N) -> integer(factorial/memo N) -> integer(*factorial/memo N) -> integer

N: integer

factorial-

*factorial-

(factorial- N FALL) -> real(*factorial- N FALL) -> real

The falling factorial.

N: real
FALL: integer

factorial+

*factorial+

(factorial+ N RISE) -> real(*factorial+ N RISE) -> real

The rising factorial.

N: real
RISE: integer

harmonic

*harmonic

harmonic/memo

*harmonic/memo

(harmonic N) -> real(*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

(to-places PREC (FUNC EXPR))(@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 ; range start
N2: number ; range end

big-sigma

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

Sum of F in N1 to N2.

F: (number -> number) ;
N1: number ; range start
N2: number ; range end

prod

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

Product of BODY... in N1 to N2, inclusive, by STEP. When N1 > N2 the STEP becomes negative.

VAR: symbol ; VAR bound to current N in BODY...
BODY...: number ;
N1: number ; range start
N2: number ; range end
STEP: number ; step size, positive, default 1

summ

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

Sum of BODY... in N1 to N2, inclusive, by STEP. When N1 > N2 the STEP becomes negative.

VAR: symbol ; VAR bound to current N in BODY...
BODY...: number ;
N1: number ; range start
N2: number ; range end
STEP: number ; step size, positive, default 1

Integration Functions

Usage

(import (math-utils integration))

trapezoid

[procedure] (trapezoid F A B) -> (fixnum -> number)

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

F: (number -> number) ; function to integrate
A: number ; lower bound
B: number ; upper bound

simpson

[procedure] (simpson F A B [N]) -> (fixnum -> number)

Calculate the area under F between A & B

F: (number -> number) ; function to integrate
A: number ; lower bound
B: number ; upper bound
N: fixnum ; interval count, default 6.

Composite Simpson's 1/3 rule.

simpson/adaptive

[procedure] (simpson/adaptive F A B EPSILON) -> (fixnum -> number)

F: (number -> number) ; function to integrate
A: number ; lower bound
B: number ; upper bound
EPSILON: real ; error threshold for result

gamma

[procedure] (gamma N EPSILON) -> real

The gamma function at N.

N: real
EPSILON: real ; error threshold for result

Regession Functions

Usage

(import (math-utils regression))

linear-regression

[procedure] (linear-regression SRC) -> real real

Returns the slope & intercept values of the line fitted to the data from SRC.

SRC: (or list vector (-> (or eof *)))

linear-extrapolator

[procedure] (linear-extrapolator SRC) -> (real -> real)

Returns a procedure taking the x coordinate of the line fitted to the data from SRC, and return the y.

SRC: (or (list-of real) (vector-of real) (-> (or eof real)))

big-sigma*

big-pi*

(big-sigma* SRC REDUCER ...) -> * ...(big-pi* SRC REDUCER ...) -> * ...

Returns reduced values for each REDUCER, in order.

SRC: (or list vector (-> (or eof *)))
REDUCER: (#!rest * -> real)

accumulate-step

[procedure] (accumulate-step ('a 'a -> 'a) (list-of (#!rest * -> 'a)) (list-of 'a) *) -> (list-of 'a)

summs-accumulate-step

prods-accumulate-step

(summs-accumulate-step (real real -> real) (list-of (#!rest * -> real)) (list-of real) *) -> (list-of real)(prods-accumulate-step (real real -> real) (list-of (#!rest * -> real)) (list-of real) *) -> (list-of real)

reduce-data

[procedure] (reduce-data SRC ACC REDUCER ...) -> * ...

Returns reduced values for each REDUCER, in order.

SRC: (or list vector (-> (or eof *)))
ACC: ((list-of (#!rest * -> 'a)) (list-of 'a) * -> (list-of 'a))
REDUCER: (#!rest * -> *)

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

[procedure] (vector-compare VEC ... [DIFF]) -> number

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

VEC: (vector) ; .
DIFF: ((* * -> number)) ; quantified difference function.

vector-compare2

[procedure] (vector-compare2 VEC1 VEC2 [DIFF]) -> number

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

VEC1: (vector-of 'a) ; .
VEC2: (vector-of 'b) ; .
DIFF: (('a 'b -> number)) ; quantified difference function.

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

vector-prod

vector-min

vector-max

(vector-sum NUMVEC) -> number(vector-prod NUMVEC) -> number(vector-min NUMVEC) -> number(vector-max 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)).

NUMVEC: (vector-of number) ; .

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.

NUMVEC: (vector-of number) ; .
TEMP: real ; temperature, default 1.

vector-reduce

[procedure] (vector-reduce FUNC SEED VEC [START [END]]) -> (vector-of 'a)

FUNC: ('a 'b -> 'a) ; .
SEED: 'a ; initial value.
VEC: (vector-of 'b ; vector to reduce.
START: fixnum ; start index of VEC, default 0.
END: fixnum ; end index of VEC, default (vector-length VEC).

vector-reduce

[procedure] (subvector-reduce FUNC VEC [WIDTH [OVERLAY [START [END]]]]) -> (vector-of 'a)

Returns a vector from the application of FUNC to every set of sequential WIOTH elements in VEC; the subinterval. Should the VEC have a non-integer number of subinterval the remainder is treated a vector with WIDTH the remaining length. It is up to the caller to ensure an integral subinterval count.

FUNC: ('b #!optional 'b -> 'a) ; .
VEC: (vector-of 'b ; vector to reduce.
WIDTH: fixnum ; subinterval width, default 2.
OVERLAY: fixnum ; subinterval shift, default WIDTH.
START: fixnum ; start index of VEC, default 0.
END: fixnum ; end index of VEC, default (vector-length VEC).

vector-apply

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

FUNC: ('t1 't2 ... -> 'a ; .
VEC#: (vector-of 't#) ; .

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

vector-scale

vector-shift

(vector-scale NUMVEC FACTOR) -> (vector-of number)(vector-shift NUMVEC BIAS) -> (vector-of number)

NUMVEC: (vector-of number) ; .

normalize-vector-scale

normalize-vector-shift

(normalize-vector-scale NUMVEC) -> (vector-of number)(normalize-vector-shift NUMVEC) -> (vector-of number)

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

NUMVEC: (vector-of number) ; .

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 fx-utils

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.18.0: Add subvector-reduce overlay argument. summ & prod will count down.
1.17.0: Add subvector-reduce. Widen vector type, not just number, for vector-apply. vector-compare, & vector-reduce. Add optional difference function argument to vector-compare*. Add integration & regression modules. moving trapezoid & linear-regression.
1.16.0: Add minimum, maximum, range-value, fxrnd.
1.15.2: Change factorial+/-.
1.15.1: Fix type signatures.
1.15.0: CHICKEN 6 release. Remove square (scheme base). Add accumulate-step, summs-accumulate-step, prods-accumulate-step, reduce-data, big-sigma*, big-pi*, linear-regression, linear-extrapolator.

License

This code is in the public domain.