Handy math package for Common Lisp

handy-math.lisp

(defpackage #:handy-math
  (:use #:cl)
  (:export #:onep #:twop
           #:one-over #:1/ #:halve #:/2 #:integer-factor-p #:factorer
           #:two-fold #:2* #:multiplier
           #:^ #:2^ #:^2
           #:v*)
  (:documentation "Handy Math

Simple, often used arithmatic operations."))

(in-package #:handy-math)

;;; Predicates

(defun onep (a-number)
  "True if `a-number' is 1."
  (declare (type number a-number))
  (= 1 a-number))

(defun twop (a-number)
  "True if `a-number' is 2."
  (declare (type number a-number))
  (= 2 a-number))


;;; Divisions

(defun one-over (a-number)
  "Return `1/a-number'."
  (declare (type number a-number))
  (/ 1 a-number))

(defun |1/| (a-number)
  ;; Use quoted symbol to avoid confusion with ratio syntax.
  "Return `1/a-number'."
  (one-over a-number))

(defun halve (a-number)
  "Return `a-number/2'."
  (declare (type number a-number))
  (/ a-number 2))

(defun /2 (a-number)
  "Return `a-number/2'."
  (halve a-number))

(defun integer-factor-p (dividend divisor)
  "True if `divisor' is integer factor of `dividend'."
  (declare (type integer dividend divisor))
  (zerop (mod dividend divisor)))

(defun factorer (dividend)
  "Returns lambda testing if argument is integer factor of `dividend'."
  (lambda (divisor)
    (integer-factor-p dividend divisor)))


;;; 

(defun two-fold (a-number)
  ;; `double' is reserved.
  "Returns `2*a-number'."
  (declare (type number a-number))
  (* 2 a-number))

(defun 2* (a-number)
  "Returns `2*a-number'."
  (two-fold a-number))

(defun multiplier (multiplier)
  "Returns lambda of `multiplier'."
  (declare (type number multiplier))
  (lambda (multiplicand)
    (declare (type number multiplicand))
    (* multiplicand multiplier)))


;;; Powers

(defun ^ (base exponent)
  "Returns the power of `base' to `exponent'."
  (declare (type number base exponent))
  (expt base exponent))

(defun 2^ (a-number)
  "Returns `2^a-number'."
  (declare (type number a-number))
  (expt 2 a-number))

(defun ^2 (a-number)
  "Returns `a-number^2'."
  (declare (type number a-number))
  (expt a-number 2))


;;; Matrices

(defun v* (vector &rest vectors)
  "Returns vector product of arguments."
  (flet ((vector-product (m1 &optional m2)
           (if m2
               (map 'list #'* m1 m2)
               m1)))
    (reduce #'vector-product (list* vector vectors))))