-;; Calculator for GNU Emacs, part II [calc-comb.el]
-;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
-;; Written by Dave Gillespie, daveg@synaptics.com.
+;;; calc-comb.el --- combinatoric functions for Calc
+
+;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
+;; 2005, 2006 Free Software Foundation, Inc.
+
+;; Author: David Gillespie <daveg@synaptics.com>
+;; Maintainer: Jay Belanger <belanger@truman.edu>
;; This file is part of GNU Emacs.
;; file named COPYING. Among other things, the copyright notice
;; and this notice must be preserved on all copies.
+;;; Commentary:
+;;; Code:
;; This file is autoloaded from calc-ext.el.
-(require 'calc-ext)
+(require 'calc-ext)
(require 'calc-macs)
-(defun calc-Need-calc-comb () nil)
+(defconst math-primes-table
+ [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89
+ 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181
+ 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277
+ 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383
+ 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487
+ 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601
+ 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709
+ 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827
+ 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947
+ 953 967 971 977 983 991 997 1009 1013 1019 1021 1031 1033 1039 1049
+ 1051 1061 1063 1069 1087 1091 1093 1097 1103 1109 1117 1123 1129 1151
+ 1153 1163 1171 1181 1187 1193 1201 1213 1217 1223 1229 1231 1237 1249
+ 1259 1277 1279 1283 1289 1291 1297 1301 1303 1307 1319 1321 1327 1361
+ 1367 1373 1381 1399 1409 1423 1427 1429 1433 1439 1447 1451 1453 1459
+ 1471 1481 1483 1487 1489 1493 1499 1511 1523 1531 1543 1549 1553 1559
+ 1567 1571 1579 1583 1597 1601 1607 1609 1613 1619 1621 1627 1637 1657
+ 1663 1667 1669 1693 1697 1699 1709 1721 1723 1733 1741 1747 1753 1759
+ 1777 1783 1787 1789 1801 1811 1823 1831 1847 1861 1867 1871 1873 1877
+ 1879 1889 1901 1907 1913 1931 1933 1949 1951 1973 1979 1987 1993 1997
+ 1999 2003 2011 2017 2027 2029 2039 2053 2063 2069 2081 2083 2087 2089
+ 2099 2111 2113 2129 2131 2137 2141 2143 2153 2161 2179 2203 2207 2213
+ 2221 2237 2239 2243 2251 2267 2269 2273 2281 2287 2293 2297 2309 2311
+ 2333 2339 2341 2347 2351 2357 2371 2377 2381 2383 2389 2393 2399 2411
+ 2417 2423 2437 2441 2447 2459 2467 2473 2477 2503 2521 2531 2539 2543
+ 2549 2551 2557 2579 2591 2593 2609 2617 2621 2633 2647 2657 2659 2663
+ 2671 2677 2683 2687 2689 2693 2699 2707 2711 2713 2719 2729 2731 2741
+ 2749 2753 2767 2777 2789 2791 2797 2801 2803 2819 2833 2837 2843 2851
+ 2857 2861 2879 2887 2897 2903 2909 2917 2927 2939 2953 2957 2963 2969
+ 2971 2999 3001 3011 3019 3023 3037 3041 3049 3061 3067 3079 3083 3089
+ 3109 3119 3121 3137 3163 3167 3169 3181 3187 3191 3203 3209 3217 3221
+ 3229 3251 3253 3257 3259 3271 3299 3301 3307 3313 3319 3323 3329 3331
+ 3343 3347 3359 3361 3371 3373 3389 3391 3407 3413 3433 3449 3457 3461
+ 3463 3467 3469 3491 3499 3511 3517 3527 3529 3533 3539 3541 3547 3557
+ 3559 3571 3581 3583 3593 3607 3613 3617 3623 3631 3637 3643 3659 3671
+ 3673 3677 3691 3697 3701 3709 3719 3727 3733 3739 3761 3767 3769 3779
+ 3793 3797 3803 3821 3823 3833 3847 3851 3853 3863 3877 3881 3889 3907
+ 3911 3917 3919 3923 3929 3931 3943 3947 3967 3989 4001 4003 4007 4013
+ 4019 4021 4027 4049 4051 4057 4073 4079 4091 4093 4099 4111 4127 4129
+ 4133 4139 4153 4157 4159 4177 4201 4211 4217 4219 4229 4231 4241 4243
+ 4253 4259 4261 4271 4273 4283 4289 4297 4327 4337 4339 4349 4357 4363
+ 4373 4391 4397 4409 4421 4423 4441 4447 4451 4457 4463 4481 4483 4493
+ 4507 4513 4517 4519 4523 4547 4549 4561 4567 4583 4591 4597 4603 4621
+ 4637 4639 4643 4649 4651 4657 4663 4673 4679 4691 4703 4721 4723 4729
+ 4733 4751 4759 4783 4787 4789 4793 4799 4801 4813 4817 4831 4861 4871
+ 4877 4889 4903 4909 4919 4931 4933 4937 4943 4951 4957 4967 4969 4973
+ 4987 4993 4999 5003])
+;; The variable math-prime-factors-finished is set by calcFunc-prfac to
+;; indicate whether factoring is complete, and used by calcFunc-factors,
+;; calcFunc-totient and calcFunc-moebius.
+(defvar math-prime-factors-finished)
;;; Combinatorics
(defun calc-gcd (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-binary-op "gcd" 'calcFunc-gcd arg))
-)
+ (calc-binary-op "gcd" 'calcFunc-gcd arg)))
(defun calc-lcm (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-binary-op "lcm" 'calcFunc-lcm arg))
-)
+ (calc-binary-op "lcm" 'calcFunc-lcm arg)))
(defun calc-extended-gcd ()
(interactive)
(calc-slow-wrapper
- (calc-enter-result 2 "egcd" (cons 'calcFunc-egcd (calc-top-list-n 2))))
-)
+ (calc-enter-result 2 "egcd" (cons 'calcFunc-egcd (calc-top-list-n 2)))))
(defun calc-factorial (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-unary-op "fact" 'calcFunc-fact arg))
-)
+ (calc-unary-op "fact" 'calcFunc-fact arg)))
(defun calc-gamma (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-unary-op "gmma" 'calcFunc-gamma arg))
-)
+ (calc-unary-op "gmma" 'calcFunc-gamma arg)))
(defun calc-double-factorial (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-unary-op "dfac" 'calcFunc-dfact arg))
-)
+ (calc-unary-op "dfac" 'calcFunc-dfact arg)))
(defun calc-choose (arg)
(interactive "P")
(calc-slow-wrapper
(if (calc-is-hyperbolic)
(calc-binary-op "perm" 'calcFunc-perm arg)
- (calc-binary-op "chos" 'calcFunc-choose arg)))
-)
+ (calc-binary-op "chos" 'calcFunc-choose arg))))
(defun calc-perm (arg)
(interactive "P")
(calc-hyperbolic-func)
- (calc-choose arg)
-)
+ (calc-choose arg))
(defvar calc-last-random-limit '(float 1 0))
(defun calc-random (n)
(prefix-numeric-value n))))
(calc-enter-result 1 "rand" (list 'calcFunc-random
(calc-get-random-limit
- (calc-top-n 1))))))
-)
+ (calc-top-n 1)))))))
(defun calc-get-random-limit (val)
(if (eq val 0)
calc-last-random-limit
- (setq calc-last-random-limit val))
-)
+ (setq calc-last-random-limit val)))
(defun calc-rrandom ()
(interactive)
(calc-slow-wrapper
(setq calc-last-random-limit '(float 1 0))
- (calc-enter-result 0 "rand" (list 'calcFunc-random '(float 1 0))))
-)
+ (calc-enter-result 0 "rand" (list 'calcFunc-random '(float 1 0)))))
(defun calc-random-again (arg)
(interactive "p")
(calc-slow-wrapper
(while (>= (setq arg (1- arg)) 0)
(calc-enter-result 0 "rand" (list 'calcFunc-random
- calc-last-random-limit))))
-)
+ calc-last-random-limit)))))
(defun calc-shuffle (n)
(interactive "P")
(calc-enter-result 2 "shuf" (list 'calcFunc-shuffle
(calc-top-n 1)
(calc-get-random-limit
- (calc-top-n 2))))))
-)
+ (calc-top-n 2)))))))
(defun calc-report-prime-test (res)
(cond ((eq (car res) t)
"prim" "Probably prime (%d iters; %s%% chance of error)"
(nth 1 res)
(let ((calc-float-format '(fix 2)))
- (math-format-number (nth 2 res))))))
-)
+ (math-format-number (nth 2 res)))))))
(defun calc-prime-test (iters)
(interactive "p")
(calc-slow-wrapper
(let* ((n (calc-top-n 1))
(res (math-prime-test n iters)))
- (calc-report-prime-test res)))
-)
+ (calc-report-prime-test res))))
+
+(defvar calc-verbose-nextprime nil)
(defun calc-next-prime (iters)
(interactive "p")
(calc-enter-result 1 "prvp" (list 'calcFunc-prevprime
(calc-top-n 1) (math-abs iters)))
(calc-enter-result 1 "nxtp" (list 'calcFunc-nextprime
- (calc-top-n 1) (math-abs iters))))))
-)
+ (calc-top-n 1) (math-abs iters)))))))
(defun calc-prev-prime (iters)
(interactive "p")
(calc-invert-func)
- (calc-next-prime iters)
-)
+ (calc-next-prime iters))
(defun calc-prime-factors (iters)
(interactive "p")
(let ((res (calcFunc-prfac (calc-top-n 1))))
(if (not math-prime-factors-finished)
(calc-record-message "pfac" "Warning: May not be fully factored"))
- (calc-enter-result 1 "pfac" res)))
-)
+ (calc-enter-result 1 "pfac" res))))
(defun calc-totient (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-unary-op "phi" 'calcFunc-totient arg))
-)
+ (calc-unary-op "phi" 'calcFunc-totient arg)))
(defun calc-moebius (arg)
(interactive "P")
(calc-slow-wrapper
- (calc-unary-op "mu" 'calcFunc-moebius arg))
-)
-
-
-
+ (calc-unary-op "mu" 'calcFunc-moebius arg)))
(defun calcFunc-gcd (a b)
(list 'calcFunc-gcd a b))
(t
(calc-record-why 'integerp b)
- (list 'calcFunc-gcd a b)))
-)
+ (list 'calcFunc-gcd a b))))
(defun calcFunc-lcm (a b)
(let ((g (calcFunc-gcd a b)))
(if (Math-numberp g)
(math-div (math-mul a b) g)
- (list 'calcFunc-lcm a b)))
-)
+ (list 'calcFunc-lcm a b))))
(defun calcFunc-egcd (a b) ; Knuth section 4.5.2
(cond
t2 (math-sub u2 (math-mul v2 (car q)))
u1 v1 u2 v2 u3 v3
v1 t1 v2 t2 v3 (cdr q)))
- (list 'vec u3 u1 u2))))
-)
+ (list 'vec u3 u1 u2)))))
;;; Factorial and related functions.
(math-div
(math-pow -2 (- tn))
(math-double-factorial-iter (* -2 tn) 3 1 2))
- (math-div
+ (math-div
(math-double-factorial-iter (* 2 tn) 3 1 2)
(math-pow 2 tn)))))
(math-mul q (if calc-symbolic-mode
(math-gammap1-raw (math-float n)))))))
((equal n '(var inf var-inf)) n)
(t (calc-record-why 'numberp n)
- (list 'calcFunc-fact n))))
-)
+ (list 'calcFunc-fact n)))))
(math-defcache math-gamma-1q nil
(math-with-extra-prec 3
(math-working (format "factorial(%d)" (1- n)) f))
(if (> count 0)
(math-factorial-iter (1- count) (1+ n) (math-mul n f))
- f)
-)
+ f))
(defun calcFunc-dfact (n) ; [I I] [F F] [Public]
(cond ((Math-integer-negp n)
(if (math-evenp temp)
even
(math-div (calcFunc-fact n) even))))
- (list 'calcFunc-dfact max))))
+ (list 'calcFunc-dfact n))))
((equal n '(var inf var-inf)) n)
(t (calc-record-why 'natnump n)
- (list 'calcFunc-dfact n)))
-)
+ (list 'calcFunc-dfact n))))
(defun math-double-factorial-iter (max n f step)
(if (< (% n 12) step)
(math-working (format "dfact(%d)" (- n step)) f))
(if (<= n max)
(math-double-factorial-iter max (+ n step) (math-mul n f) step)
- f)
-)
+ f))
(defun calcFunc-perm (n m) ; [I I I] [F F F] [Public]
(cond ((and (integerp n) (integerp m) (<= m n) (>= m 0))
(or (integerp tm) (math-reject-arg tm 'fixnump))
(or (and (<= tm tn) (>= tm 0)) (math-reject-arg tm 'range))
(math-with-extra-prec 1
- (math-factorial-iter tm (1+ (- tn tm)) '(float 1 0))))))
-)
+ (math-factorial-iter tm (1+ (- tn tm)) '(float 1 0)))))))
(defun calcFunc-choose (n m) ; [I I I] [F F F] [Public]
(cond ((and (integerp n) (integerp m) (<= m n) (>= m 0))
(calcFunc-fact (math-float
(math-sub n m)))))
(math-with-extra-prec 1
- (math-choose-float-iter tm n 1 1))))))
-)
+ (math-choose-float-iter tm n 1 1)))))))
(defun math-choose-iter (m n i c)
(if (and (= (% i 5) 1) (> i 5))
(if (<= i m)
(math-choose-iter m (1- n) (1+ i)
(math-quotient (math-mul c n) i))
- c)
-)
+ c))
(defun math-choose-float-iter (count n i c)
(if (= (% i 5) 1)
(if (> count 0)
(math-choose-float-iter (1- count) (math-sub n 1) (1+ i)
(math-div (math-mul c n) i))
- c)
-)
+ c))
;;; Stirling numbers.
(defun calcFunc-stir1 (n m)
- (math-stirling-number n m 1)
-)
+ (math-stirling-number n m 1))
(defun calcFunc-stir2 (n m)
- (math-stirling-number n m 0)
-)
+ (math-stirling-number n m 0))
+
+(defvar math-stirling-cache (vector [[1]] [[1]]))
+
+;; The variable math-stirling-local-cache is local to
+;; math-stirling-number, but is used by math-stirling-1
+;; and math-stirling-2, which are called by math-stirling-number.
+(defvar math-stirling-local-cache)
(defun math-stirling-number (n m k)
(or (math-num-natnump n) (math-reject-arg n 'natnump))
(or (integerp m) (math-reject-arg m 'fixnump))
(if (< n m)
0
- (let ((cache (aref math-stirling-cache k)))
- (while (<= (length cache) n)
- (let ((i (1- (length cache)))
+ (let ((math-stirling-local-cache (aref math-stirling-cache k)))
+ (while (<= (length math-stirling-local-cache) n)
+ (let ((i (1- (length math-stirling-local-cache)))
row)
- (setq cache (vconcat cache (make-vector (length cache) nil)))
- (aset math-stirling-cache k cache)
- (while (< (setq i (1+ i)) (length cache))
- (aset cache i (setq row (make-vector (1+ i) nil)))
+ (setq math-stirling-local-cache
+ (vconcat math-stirling-local-cache
+ (make-vector (length math-stirling-local-cache) nil)))
+ (aset math-stirling-cache k math-stirling-local-cache)
+ (while (< (setq i (1+ i)) (length math-stirling-local-cache))
+ (aset math-stirling-local-cache i (setq row (make-vector (1+ i) nil)))
(aset row 0 0)
(aset row i 1))))
(if (= k 1)
(math-stirling-1 n m)
- (math-stirling-2 n m))))
-)
-(setq math-stirling-cache (vector [[1]] [[1]]))
+ (math-stirling-2 n m)))))
(defun math-stirling-1 (n m)
- (or (aref (aref cache n) m)
- (aset (aref cache n) m
+ (or (aref (aref math-stirling-local-cache n) m)
+ (aset (aref math-stirling-local-cache n) m
(math-add (math-stirling-1 (1- n) (1- m))
- (math-mul (- 1 n) (math-stirling-1 (1- n) m)))))
-)
+ (math-mul (- 1 n) (math-stirling-1 (1- n) m))))))
(defun math-stirling-2 (n m)
- (or (aref (aref cache n) m)
- (aset (aref cache n) m
+ (or (aref (aref math-stirling-local-cache n) m)
+ (aset (aref math-stirling-local-cache n) m
(math-add (math-stirling-2 (1- n) (1- m))
- (math-mul m (math-stirling-2 (1- n) m)))))
-)
+ (math-mul m (math-stirling-2 (1- n) m))))))
+(defvar math-random-table nil)
+(defvar math-last-RandSeed nil)
+(defvar math-random-ptr1 nil)
+(defvar math-random-ptr2 nil)
+(defvar math-random-shift nil)
;;; Produce a random 10-bit integer, with (random) if no seed provided,
;;; or else with Numerical Recipes algorithm ran3 / Knuth 3.2.2-A.
+
+(defvar var-RandSeed)
+(defvar math-random-cache nil)
+(defvar math-gaussian-cache nil)
+
(defun math-init-random-base ()
(if (and (boundp 'var-RandSeed) var-RandSeed)
(if (eq (car-safe var-RandSeed) 'vec)
(random t)
(setq var-RandSeed nil
math-random-cache nil
- i 0
math-random-shift -4) ; assume RAND_MAX >= 16383
;; This exercises the random number generator and also helps
;; deduce a better value for RAND_MAX.
- (while (< (setq i (1+ i)) 30)
- (if (> (lsh (math-abs (random)) math-random-shift) 4095)
- (setq math-random-shift (1- math-random-shift)))))
+ (let ((i 0))
+ (while (< (setq i (1+ i)) 30)
+ (if (> (lsh (math-abs (random)) math-random-shift) 4095)
+ (setq math-random-shift (1- math-random-shift))))))
(setq math-last-RandSeed var-RandSeed
- math-gaussian-cache nil)
-)
+ math-gaussian-cache nil))
(defun math-random-base ()
(if var-RandSeed
(logand (- (car math-random-ptr1)
(car math-random-ptr2)) 524287))
-6) 1023))
- (logand (lsh (random) math-random-shift) 1023))
-)
-(setq math-random-table nil)
-(setq math-last-RandSeed nil)
-(setq math-random-ptr1 nil)
-(setq math-random-ptr2 nil)
-(setq math-random-shift nil)
+ (logand (lsh (random) math-random-shift) 1023)))
;;; Produce a random digit in the range 0..999.
;;; Avoid various pitfalls that may lurk in the built-in (random) function!
;;; Shuffling algorithm from Numerical Recipes, section 7.1.
+(defvar math-random-last)
(defun math-random-digit ()
(let (i)
(or (and (boundp 'var-RandSeed) (eq var-RandSeed math-last-RandSeed))
math-random-last (aref math-random-cache i))
(aset math-random-cache i (math-random-base))
(>= math-random-last 1000)))
- math-random-last)
-)
-(setq math-random-cache nil)
+ math-random-last))
;;; Produce an N-digit random integer.
(defun math-random-digits (n)
(setq digs (cons (math-random-digit) digs)
i (1- i)))
(math-normalize (math-scale-right (cons 'bigpos digs)
- slop)))))
-)
+ slop))))))
;;; Produce a uniformly-distributed random float 0 <= N < 1.
(defun math-random-float ()
(math-make-float (math-random-digits calc-internal-prec)
- (- calc-internal-prec))
-)
+ (- calc-internal-prec)))
;;; Produce a Gaussian-distributed random float with mean=0, sigma=1.
(defun math-gaussian-float ()
(let ((fac (math-sqrt (math-mul (math-div (calcFunc-ln r) r) -2))))
(setq math-gaussian-cache (cons calc-internal-prec
(math-mul v1 fac)))
- (math-mul v2 fac)))))
-)
-(setq math-gaussian-cache nil)
+ (math-mul v2 fac))))))
;;; Produce a random integer or real 0 <= N < MAX.
(defun calcFunc-random (max)
(math-reject-arg max "*Empty list")))
((and (eq (car max) 'sdev) (math-constp max) (Math-realp (nth 1 max)))
(math-add (math-mul (math-gaussian-float) (nth 2 max)) (nth 1 max)))
- (t (math-reject-arg max 'realp)))
-)
+ (t (math-reject-arg max 'realp))))
;;; Choose N objects at random from the set MAX without duplicates.
(defun calcFunc-shuffle (n &optional max)
(if (math-posp max)
(calcFunc-shuffle n (list 'intv 2 0 max))
(calcFunc-shuffle n (list 'intv 1 max 0))))
- (t (math-reject-arg max 'realp)))
-)
+ (t (math-reject-arg max 'realp))))
(defun math-simple-shuffle (n max)
(let ((vec nil)
(while (>= (setq n (1- n)) 0)
(while (math-member (setq val (calcFunc-random max)) vec))
(setq vec (cons val vec)))
- (cons 'vec vec))
-)
+ (cons 'vec vec)))
(defun math-shuffle-list (n size vec)
(let ((j size)
temp (nth k p))
(setcar (nthcdr k p) (car p))
(setcar p temp))
- (cons 'vec (nthcdr (- size n -1) vec)))
-)
+ (cons 'vec (nthcdr (- size n -1) vec))))
(defun math-member (x list)
(while (and list (not (equal x (car list))))
(setq list (cdr list)))
- list
-)
+ list)
;;; Check if the integer N is prime. [X I]
;;; (nil unknown) if non-prime with no known factors,
;;; (t) if prime,
;;; (maybe N P) if probably prime (after N iters with probability P%)
+(defvar math-prime-test-cache '(-1))
+
+(defvar math-prime-test-cache-k)
+(defvar math-prime-test-cache-q)
+(defvar math-prime-test-cache-nm1)
+
(defun math-prime-test (n iters)
(if (and (Math-vectorp n) (cdr n))
(setq n (nth (1- (length n)) n)))
iters (if (eq (car res) 'maybe)
(1- iters)
0)))
- res)
-)
-(defvar math-prime-test-cache '(-1))
+ res))
(defun calcFunc-prime (n &optional iters)
(or (math-num-integerp n) (math-reject-arg n 'integerp))
(or (not iters) (math-num-integerp iters) (math-reject-arg iters 'integerp))
(if (car (math-prime-test (math-trunc n) (math-trunc (or iters 1))))
1
- 0)
-)
+ 0))
;;; Theory: summing base-10^6 digits modulo 111111 is "casting out 999999s".
;;; Initial probability that N is prime is 1/ln(N) = log10(e)/log10(N).
(list 'vec n)
(cons 'vec (cons -1 (cdr (calcFunc-prfac (math-neg n))))))
(calc-record-why 'integerp n)
- (list 'calcFunc-prfac n)))
-)
+ (list 'calcFunc-prfac n))))
(defun calcFunc-totient (n)
(if (Math-messy-integerp n)
(calc-record-why "*Number too big to factor" n)
(list 'calcFunc-totient n))))
(calc-record-why 'natnump n)
- (list 'calcFunc-totient n))
-)
+ (list 'calcFunc-totient n)))
(defun calcFunc-moebius (n)
(if (Math-messy-integerp n)
(calc-record-why "Number too big to factor" n)
(list 'calcFunc-moebius n))))
(calc-record-why 'posintp n)
- (list 'calcFunc-moebius n))
-)
+ (list 'calcFunc-moebius n)))
(defun calcFunc-nextprime (n &optional iters)
n))
(if (Math-realp n)
(calcFunc-nextprime (math-trunc n) iters)
- (math-reject-arg n 'integerp)))
-)
-(setq calc-verbose-nextprime nil)
+ (math-reject-arg n 'integerp))))
(defun calcFunc-prevprime (n &optional iters)
(if (Math-integerp n)
n)
(if (Math-realp n)
(calcFunc-prevprime (math-ceiling n) iters)
- (math-reject-arg n 'integerp)))
-)
+ (math-reject-arg n 'integerp))))
(defun math-next-small-prime (n)
(if (and (integerp n) (> n 2))
(setq lo mid)
(setq hi mid)))
(aref math-primes-table hi))
- 2)
-)
-
-(defconst math-primes-table
- [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89
- 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181
- 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277
- 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383
- 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487
- 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601
- 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709
- 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827
- 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947
- 953 967 971 977 983 991 997 1009 1013 1019 1021 1031 1033 1039 1049
- 1051 1061 1063 1069 1087 1091 1093 1097 1103 1109 1117 1123 1129 1151
- 1153 1163 1171 1181 1187 1193 1201 1213 1217 1223 1229 1231 1237 1249
- 1259 1277 1279 1283 1289 1291 1297 1301 1303 1307 1319 1321 1327 1361
- 1367 1373 1381 1399 1409 1423 1427 1429 1433 1439 1447 1451 1453 1459
- 1471 1481 1483 1487 1489 1493 1499 1511 1523 1531 1543 1549 1553 1559
- 1567 1571 1579 1583 1597 1601 1607 1609 1613 1619 1621 1627 1637 1657
- 1663 1667 1669 1693 1697 1699 1709 1721 1723 1733 1741 1747 1753 1759
- 1777 1783 1787 1789 1801 1811 1823 1831 1847 1861 1867 1871 1873 1877
- 1879 1889 1901 1907 1913 1931 1933 1949 1951 1973 1979 1987 1993 1997
- 1999 2003 2011 2017 2027 2029 2039 2053 2063 2069 2081 2083 2087 2089
- 2099 2111 2113 2129 2131 2137 2141 2143 2153 2161 2179 2203 2207 2213
- 2221 2237 2239 2243 2251 2267 2269 2273 2281 2287 2293 2297 2309 2311
- 2333 2339 2341 2347 2351 2357 2371 2377 2381 2383 2389 2393 2399 2411
- 2417 2423 2437 2441 2447 2459 2467 2473 2477 2503 2521 2531 2539 2543
- 2549 2551 2557 2579 2591 2593 2609 2617 2621 2633 2647 2657 2659 2663
- 2671 2677 2683 2687 2689 2693 2699 2707 2711 2713 2719 2729 2731 2741
- 2749 2753 2767 2777 2789 2791 2797 2801 2803 2819 2833 2837 2843 2851
- 2857 2861 2879 2887 2897 2903 2909 2917 2927 2939 2953 2957 2963 2969
- 2971 2999 3001 3011 3019 3023 3037 3041 3049 3061 3067 3079 3083 3089
- 3109 3119 3121 3137 3163 3167 3169 3181 3187 3191 3203 3209 3217 3221
- 3229 3251 3253 3257 3259 3271 3299 3301 3307 3313 3319 3323 3329 3331
- 3343 3347 3359 3361 3371 3373 3389 3391 3407 3413 3433 3449 3457 3461
- 3463 3467 3469 3491 3499 3511 3517 3527 3529 3533 3539 3541 3547 3557
- 3559 3571 3581 3583 3593 3607 3613 3617 3623 3631 3637 3643 3659 3671
- 3673 3677 3691 3697 3701 3709 3719 3727 3733 3739 3761 3767 3769 3779
- 3793 3797 3803 3821 3823 3833 3847 3851 3853 3863 3877 3881 3889 3907
- 3911 3917 3919 3923 3929 3931 3943 3947 3967 3989 4001 4003 4007 4013
- 4019 4021 4027 4049 4051 4057 4073 4079 4091 4093 4099 4111 4127 4129
- 4133 4139 4153 4157 4159 4177 4201 4211 4217 4219 4229 4231 4241 4243
- 4253 4259 4261 4271 4273 4283 4289 4297 4327 4337 4339 4349 4357 4363
- 4373 4391 4397 4409 4421 4423 4441 4447 4451 4457 4463 4481 4483 4493
- 4507 4513 4517 4519 4523 4547 4549 4561 4567 4583 4591 4597 4603 4621
- 4637 4639 4643 4649 4651 4657 4663 4673 4679 4691 4703 4721 4723 4729
- 4733 4751 4759 4783 4787 4789 4793 4799 4801 4813 4817 4831 4861 4871
- 4877 4889 4903 4909 4919 4931 4933 4937 4943 4951 4957 4967 4969 4973
- 4987 4993 4999 5003])
-
-
+ 2))
+(provide 'calc-comb)
+;;; arch-tag: 1d75ee9b-0815-42bd-a321-bb3dc001cc02
+;;; calc-comb.el ends here