Rosetta Code

User:Spekkio: Difference between revisions

User page Discussion

User:Spekkio (view source)

Revision as of 15:30, 27 August 2013

1,981 bytes added ,  10 years ago
no edit summary
No edit summary
No edit summary
 
(18 intermediate revisions by the same user not shown)
Line 2:
{{mylang|C|Active}}
{{mylang|C++|Beginner}}
{{mylang|GLSL|Beginner}}
{{mylang|Java|Active}}
{{mylang|JavaScript|Active}}
Line 13 ⟶ 14:
{{mylang|Pascal|Rusty}}
{{mylang|x86 Assembly|Rusty}}
{{mylang|VHDL|Rusty}}
{{mylangend}}
 
<lang lisp>(defun pie() 31415926535897932384626433832795028841971693993751058209749/10000000000000000000000000000000000000000000000000000000000)
 
(defun factorial-rec (n)
Hello! I'm a Electronic Engineer, working with electronics developement.
 
 
I love computer programming, and my hobby is to program small simple computer programs.
 
I usually get stuck on an idea that I think would be fun to try and solve.
 
I love learning new programming languages.
 
Found this page recently, and it is perfect for me. :D
 
 
Currently I'm working on Huffman coding in C, and implementing a multi precision library to calculate
 
maclaurin series for different functions sin/cos/sqrt/pow etc... (see my recent post in [[Talk:Nth root]])
 
<lang lisp>
(defun factorial (n)
(if (= n 0)
1
(* n (factorial-rec (- n 1)))))
 
(defun powintfactorial (an b&key (result 1))
(if (< n 2)
result
(factorial (- n 1) :result (* result n))))
 
(defun powint (a b &key (result 1))
(if (= b 0)
1result
(* a (powint aif (-> b 1))))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 powpower (a b n)
(if (= n 0)
1
(+
(+ (* (binom b n) (powint (- a 1) n)) (pow a b (- n 1)))))
(* (binom b n) (powint (- a 1) n))
(power a b (- n 1)))))
 
(defun powerw(a b n prev)
(defun logS(x n) (if (= n 0) (* 2 x) (+ (* 2 (/ (powint x (+ (* 2 n) 1)) (+ (* 2 n) 1))) (logS x (- n 1)) ) ))
(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 loge(x n)pow (logS (/ (- x 1) (+ 1 x))a n)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)
(defun expon(x n) (if (= n 0) 1 (+ (/ (powint x n) (factorial n)) (expon x (- n 1)))))
(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 sqrtnlogS(x n) (exponif (= n 0) (* 1/2 (loge x n)) n))
(+ (* 2 (/ (powint x (+ (* 2 n) 1)) (+ (* 2 n) 1)))
(logS x (- n 1)) ) ))
 
(defun pownloge(x a n) (exponlogw (* a/ (loge- x n1) (+ 1 x)) n0 0) )
 
(defun sinelogetest(xa n prev)
(let (if(n10 (=+ n10 0n)))
(let (( log10 (loge a n10) ))
x
(+ (* (/ (powint -1 n) (factorial (+ (* 2 n) 1)) ) (powint x (+ (* 2 n) 1))) (sine x (- n 1)))))
 
(defun sinetest(x n)
(if
(= (*float (sine x (1+ n)) 1.0log10) (* (sine x n)float 1.0prev))
(sine x n)log10
(sinetestlogetest xa (1+n10 n)log10)
)
)
))
 
(defun mysinln (x) (sinetest x 1))
(if (> x 0)
(loge x)
nil
))
 
(defun expw(x n prev)
(defun cosi(x n) (if (= n 0) 1 (+ (* (/ (powint -1 n) (factorial (* 2 n)) ) (powint x (* 2 n))) (cosi x (- n 1)))))
(let ((cosn (/ (powint x n) (factorial n))
))
(handler-case
(progn
(float cosn)
(expw x (1+ n) (+ prev cosn))
)
(arithmetic-error (x) prev ))
)
)
 
(defun tangexpon(x n) (/ (sineexpw x n)0 (cosi x n)0))
 
(defun asine squareroot(x) n(expon (* 1/2 (loge x))))
(if (= n 0)
x
(+ (/ (* (factorial (* 2 n)) (powint x (+ (* 2 n) 1))) (* (powint 4 n) (powint (factorial n) 2) (+ (* 2 n) 1))) (asine x (- n 1)))))
 
(defun powern(x a) (expon (* a (loge x))))
 
(defun asineteste (x) n(expon x))
 
(if
(defun pown (a b) (powern a b))
(= (* (asine x (1+ n)) 1.0) (* (asine x n) 1.0))
 
(asine x n)
(defun sinew(x &key (asinetestn x0) (1+prev n0))
(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 myasinfibcalc (x) (asinetest x 1)n)
(let ((sqrtFive (squareroot 5)))
(defun fibcalc (n p)
(let/ (- (powint (* 1/2 (+ 1 sqrtFive)) n) (sqrtnpowint 5(* p1/2 (- 1 sqrtFive)) n)) sqrtFive)))
(/ (- (powint (* 1/2 (+ 1 (sqrtFive))) n) (powint (* 1/2 (- 1 (sqrtFive))) n)) (sqrtFive))))
 
(defun fibrec (n)
Line 107 ⟶ 211:
1
(+ (fibrec (- n 1)) (fibrec (- n 2))))))
 
</lang>
 
(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)))))</lang>
 
test:
[314]> (asinfloat 1(asine 9/10100))
0.10016741609012195
[314]> (*asin (myasin 19/10) 1.0100)
0.10016742090121955
 
 
Compare with Mathematica:
In[14]:= N[ArcSin[19/10100], 8]
Out:[14]= 0.10016742090121945
 
(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:
(myasin) seems to be more accurate, though trying to compute (myasin 1) is very slow.
[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
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/207350...207369"