Rosetta Code

User:Spekkio: Difference between revisions

User page Discussion

User:Spekkio (view source)

Revision as of 15:30, 27 August 2013

837 bytes added ,  10 years ago
no edit summary
No edit summary
No edit summary
 
(11 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 16 ⟶ 17:
{{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 pie() 31415926535897932385/10000000000000000000)
 
(defun factorial (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)
1result
(if (> b 0)
(* a (powint a (- b 1) :result (* result a))
(*powint a (/+ 1b a1) :result (powint* aresult (+ b/ 1 a)))
)
)
Line 51 ⟶ 40:
 
(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)))))
(* (binom b n) (powint (- a 1) n))
(power a b (- n 1)))))
 
(defun powertestpowerw(a b n prev)
(let ((cosn power10(* (power abinom b n) (+powint 10(- n)a 1) n))
))
(if
(handler-case
(= (* power10 1.0) (* prev 1.0))
(progn
power10
(float cosn)
(powertest a b (+ 10 n) power10)
(if (= (+ prev cosn) prev ) prev
(powerw a b (1+ n) (+ prev cosn)))
)
(arithmetic-error (x) prev ))
)
)
Line 74 ⟶ 71:
(if (< b 1)
0
(powertestpowerw a b 10 10)
)
(if (< a 2)
(powertestpowerw a b 10 10)
0
)
Line 83 ⟶ 80:
)
 
(defun logw(x 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 (* 2 (/ (powint x (+ (* 2 n) 1)) (+ (* 2 n) 1)))
 
))
(defun loge(x n) (logS (/ (- x 1) (+ 1 x)) n))
(handler-case
 
(progn
(defun expon(x n) (if (= n 0) 1 (+ (/ (powint x n) (factorial n)) (expon x (- n 1)))))
(float cosn)
 
(defunlogw squaren(x (1+ n) (expon+ (*prev 1/2 (loge x n)) ncosn))
)
 
(defunarithmetic-error squarentest(a nx) prev ))
(let (( square10 (squaren a (+ 10 n)) ))
(if
(= (* square10 1.0) (* prev 1.0))
square10
(squarentest a (+ 10 n) square10)
)
)
)
 
(defun sqrtn logS(ax n) (squarentestif a(= 1n 0) (* 2 x)
(+ (* 2 (/ (powint x (+ (* 2 n) 1)) (+ (* 2 n) 1)))
(logS x (- n 1)) ) ))
 
(defun powernloge(x a n) (exponlogw (* a/ (loge- x n1) (+ 1 x)) n0 0) )
 
(defun powerntestlogetest(a b n prev)
(let ((n10 (+ 10 n)))
(let (( power10log10 (powernloge a b n10) ))
(if
(= (*float power10 1.0log10) (*float prev 1.0))
power10log10
(powerntestlogetest a b n10 power10log10)
)
)
))
 
(defun pownln (a b) (powerntest a b 1 0)x)
(if (> x 0)
(loge x)
nil
))
 
(defun sineexpw(x n prev)
(let ((cosn (if/ (=powint x n) 0(factorial n))
))
x
(handler-case
(+ (* (/ (powint -1 n) (factorial (+ (* 2 n) 1)) ) (powint x (+ (* 2 n) 1))) (sine x (- n 1)))))
(progn
(float cosn)
(expw x (1+ n) (+ prev cosn))
)
(arithmetic-error (x) prev ))
)
)
 
(defun sinetestexpon(x) n(expw x 0 0))
 
(if
(=defun squareroot(*x) (sine xexpon (+ 10 n))* 1.0)/2 (* (sineloge x n) 1.0)))
 
(sine x (+ 10 n))
(defun powern(x a) (expon (sinetest* xa (+loge 10 nx))))
 
)
(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 mysin sine(x) (sinetestif (= x 10) 0 (sinew x)))
 
(defun cosinew(x &key (n 0) (prev 0))
(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 -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 tangcosine(x n) (/ (sinecosinew x n) (cosi x n)))
 
(defun asinetang(x) (/ (sine x) n(cosine 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 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 asinetestasinew2(x n prev)
(let (( asine10 (asine x (+ 10 n)) 0))
(let ((next 0))
(if
 
(= (* asine10 1.0) (* prev 1.0))
(loop while (handler-case (float next) (arithmetic-error (err) NIL)) do
asine10
(progn
(asinetest x (+ 10 n) asine10)
(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 myasinasine (x)
(if (< x 1)
(if (> x -1)
(asinetestasinew x 1 0)
(/ (pie) -2)
)
Line 164 ⟶ 202:
 
(defun fibcalc (n)
(let ((sqrtFive (sqrtnsquareroot 5)))
(/ (- (powint (* 1/2 (+ 1 sqrtFive)) n) (powint (* 1/2 (- 1 sqrtFive)) n)) sqrtFive)))
 
Line 174 ⟶ 212:
(+ (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:
[14]> (*float (myasinasine 9/100) 1.0)
0.09012195
[14]> (sinasin 9/100)
0.08987855090121955
 
 
Line 190 ⟶ 229:
 
Test 2:
[4]> (*float (myasinasine (mysinsine 1)) 1.0)
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
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/207357...207369"