I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# User:Spekkio

 My Favorite Languages Language Proficiency C Active C++ Beginner GLSL Beginner Java Active JavaScript Active SQL Active Mathematica Active MATLAB Active UNIX Shell Beginner Lisp Beginner Erlang Beginner POV-Ray Beginner Pascal Rusty x86 Assembly Rusty VHDL Rusty
`(defun pie() 31415926535897932384626433832795028841971693993751058209749/10000000000000000000000000000000000000000000000000000000000) (defun factorial-rec (n)  (if (= n 0)      1    (* n (factorial-rec (- n 1))))) (defun factorial (n &key (result 1))    (if (< n 2)        result        (factorial (- n 1) :result (* result n)))) (defun powint (a b &key (result 1))  (if (= b 0)    result    (if (> b 0)    (powint a (- b 1) :result (* result a))    (powint a (+ b 1) :result (* result (/ 1 a)))    ))) (defun binom (alpha n)(if (= n 0)1  (if (= n 1)      alpha    (* (binom alpha (- n 1)) (/ (+ (- alpha n) 1) n))))) (defun power (a b n)  (if (= n 0)      1    (+(* (binom b n) (powint (- a 1) n)) (power a b (- n 1))))) (defun powerw(a b n prev)(let ((cosn (* (binom b n) (powint (- a 1) n))))(handler-case(progn(float cosn)(if (= (+ prev cosn) prev ) prev(powerw a b (1+ n) (+ prev cosn))))(arithmetic-error (x) prev )))) (defun pow (a b)  (if (< a 0)      (if (< b 1)	  0	(powerw a b 0 0)      )    (if (< a 2)	(powerw a b 0 0)      0    )  )) (defun logw(x n prev)(let ((cosn (* 2 (/ (powint x (+ (* 2 n) 1)) (+ (* 2 n) 1)))))(handler-case(progn(float cosn)(logw x (1+ n) (+ prev cosn)))(arithmetic-error (x) prev )))) (defun logS(x n) (if (= n 0) (* 2 x) (+ (* 2 (/ (powint x (+ (* 2 n) 1)) (+ (* 2 n) 1))) (logS x (- n 1)) )  )) (defun loge(x) (logw (/ (- x 1) (+ 1 x)) 0 0) ) (defun logetest(a n prev)(let ((n10 (+ 10 n)))(let (( log10 (loge a n10)  ))  (if      (= (float log10) (float prev))      log10    (logetest a n10 log10)      )))) (defun ln (x)(if (> x 0)(loge x)nil)) (defun expw(x n prev)(let ((cosn (/ (powint x n) (factorial n))))(handler-case(progn(float cosn)(expw x (1+ n) (+ prev cosn)))(arithmetic-error (x) prev )))) (defun expon(x) (expw x 0 0)) (defun squareroot(x) (expon (* 1/2 (loge x)))) (defun powern(x a) (expon (* a (loge x)))) (defun e (x) (expon x)) (defun pown (a b) (powern a b)) (defun sinew(x &key (n 0) (prev 0))(let ((cosn (* (/ (powint -1 n) (factorial (+ (* 2 n) 1)) ) (powint x (+ (* 2 n) 1)))))(handler-case(progn(float cosn)(sinew x :n (1+ n) :prev (+ prev cosn)))(arithmetic-error (x) (+ prev cosn) )))) (defun sine(x) (if (= x 0) 0 (sinew x))) (defun cosinew(x &key (n 0) (prev 0))(let ((cosn (* (/ (powint -1 n) (factorial (* 2 n))) (powint x (* 2 n)))))(handler-case(progn(float cosn)(cosinew x :n (1+ n) :prev (+ prev cosn)))(arithmetic-error (x) (+ prev cosn) )))) (defun cosine(x) (cosinew x)) (defun tang(x) (/ (sine x) (cosine x))) (defun asinew(x &key (n 0) (prev 0))(let ((cosn (/ (* (factorial (* 2 n)) (powint x (+ (* 2 n) 1))) (* (powint 4 n) (powint (factorial n) 2)  (+ (* 2 n) 1)))))(handler-case(progn(float cosn)(asinew x :n (1+ n) :prev (+ prev cosn)))(arithmetic-error (x) prev )))) (defun asinew2(x)(let ((n 0))(let ((next 0)) (loop while (handler-case (float next) (arithmetic-error (err) NIL)) do(progn(setq next (+ (/ (* (factorial (* 2 n)) (powint x (+ (* 2 n) 1))) (* (powint 4 n) (powint (factorial n) 2)  (+ (* 2 n) 1))) next))(setq n (+ n 1)))))))  (defun asine (x)  (if (< x 1)      (if (> x -1)	  (asinew x)	  (/ (pie) -2)	)    (/ (pie) 2)    )) (defun fibcalc (n)  (let ((sqrtFive (squareroot 5)))    (/ (- (powint (* 1/2 (+ 1 sqrtFive)) n) (powint (* 1/2 (- 1 sqrtFive)) n)) sqrtFive))) (defun fibrec (n)  (if (= n 0)      0    (if (= n 1)	1      (+ (fibrec (- n 1)) (fibrec (- n 2))))))  (defun test() (let ((n 0)) (loop while (< n 10) collect n do (if (= (float (sine n)) (sin n)) () (progn (write n) (write (terpri)) (write (sin n)) (write (terpri)) (write (float (sine n))) (write (terpri)) )) (setq n (+ n 1/10)))))`

test:

```[14]> (float (asine 9/100))
0.09012195
[14]> (asin 9/100)
0.090121955
```

Compare with Mathematica:

```In[14]:= N[ArcSin[9/100], 8]
Out[14]= 0.090121945
```

(myasin) seems to be more accurate, though trying to compute (myasin 9999999/10000000) is very slow.

Test 2:

```[4]> (float (asine (sine 1)))
1.0
[4]> (asin (sin 1))
1.0
```

Test 3:

```[15]> (float (sine (* 45 (/ (* 2 (pie)) 360) )))
0.70710677
[15]> (float (squareroot 1/2))
0.70710677
[15]> (= (float (squareroot 1/2)) (float (sine (* 45 (/ (* 2 (pie)) 360) ))))
T
[15]> (= (sine (* 45 (/ (* 2 (pie)) 360) )) (sine (/ (pie) 4)))
T
[15]> (= (cosine (/ (pie) 4)) (sine (/ (pie) 4)))
NIL
[15]> (= (float (cosine (/ (pie) 4))) (float (sine (/ (pie) 4))))
T
```