Elliptic curve arithmetic: Difference between revisions

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|C}}==

#include <math.h>

 

 

return 0;

{{out}}

<pre>

a + b + d = Zero

a * 12345 = (10.759, 35.387)

</pre>

 

=={{header|D}}==

{{trans|Go}}

 

enum bCoeff = 7;

writeln("a + b + d = ", a + b + d);

writeln("a * 12345 = ", a * 12345);

{{out}}

<pre>a = (-1.817, 1.000)

=={{header|EchoLisp}}==

===Arithmetic===

(require 'struct)

(decimals 4)

(printf "%d additions a+(a+(a+...))) → %a" n e)

(printf "multiplication a x %d → %a" n (E-mul a n)))

{{out}}

<pre>

===Plotting===

;; Result at http://www.echolalie.org/echolisp/help.html#plot-xy

(define (E-plot (r 3))

(define (Ellie x y) (- (* y y) (* x x x) 7))

(plot-segment R.x R.y R.x (- R.y))

)

 

=={{header|Go}}==

{{trans|C}}

 

import (

show("a + b + d = ", add(a, add(b, d)))

show("a * 12345 = ", mul(a, 12345))

{{out}}

<pre>a = (-1.817, 1.000)

a * 12345 = (10.759, 35.387)</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

c + d = Zero

a + b + d = Zero

 

=={{header|Java}}==

{{trans|D}}

import java.util.Locale;

 

return String.format(Locale.US, "(%.3f,%.3f)", this.x, this.y);

}

<pre>a = (-1.817,1.000)

b = (-1.442,2.000)

a + b + d = Zero

a * 12345 = (10.759,35.387)</pre>

 

=={{header|PARI/GP}}==

The examples were borrowed from C, though the coding is built-in for GP and so not ported.

a=[-6^(1/3),1]

b=[-3^(1/3),2]

elladd(e,c,d)

elladd(e,elladd(e,a,b),d)

{{output}}

<pre>%1 = [-1.8171205928321396588912117563272605024, 1]

=={{header|Perl}}==

{{trans|C}}

{

package EC::Point;

sub new { my $class = shift; bless [ @_ ], $class }

 

package Test;

{{out}}

<pre>EC-point at x=-1.817121, y=1.000000

EC-point at x=-1.442250, y=2.000000

EC-point at x=10.375375, y=-33.524509

</pre>

 

 

{{out}}

 

=={{header|Python}}==

{{trans|C}}

 

class Point:

show("c + d =", c.add(d))

show("a + b + d =", a.add(b.add(d)))

{{out}}

<pre>

 

=={{header|Racket}}==

#lang racket

(define a 0) (define b 7)

[(even? n) (⊗ (⊗ p (/ n 2)) 2)]

[(odd? n) (⊕ p (⊗ p (- n 1)))]))

Test:

(define (root3 x) (* (sgn x) (expt (abs x) 1/3)))

(define (y->point y) (vector (root3 (- (* y y) b)) y))

(displayln (~a "p+(q+(-(p+q))) = 0 " (zero? (⊕ p (⊕ q (neg (⊕ p q)))))))

(displayln (~a "p*12345 " (⊗ p 12345)))

Output:

p = #(-1.8171205928321397 1)

q = #(-1.4422495703074083 2)

p+(q+(-(p+q))) = 0 #t

p*12345 #(10.758570529320806 35.387434774282106)

 

=={{header|REXX}}==

 

Also, some code was added to have the output better aligned &nbsp; (for instance, negative and positive numbers).

cbrt: procedure; parse arg x; return root(x,3)

root: procedure; parse arg x,y; if x=0 | y=1 then return x/1; d=5; return rootI()/1

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

</pre>

 

=={{header|Sage}}==

Examples from C, using the built-in Elliptic curves library.

 

# a point (x,y) on Ellie, given y

return P

 

P = point(1)

Q = point(2)

S = P+Q

{{out}}

<pre>

P+Q-S (0.000000000000000 : 1.00000000000000 : 0.000000000000000) ## Zero

P*12345 (10.7585721817304 : 35.3874428812067 : 1.00000000000000)

</pre>

 

=={{header|Tcl}}==

{{trans|C}}

set zero {x inf y inf}

proc tcl::mathfunc::cuberoot n {

}

return $r

Demonstrating:

if {[iszero $p]} {

puts "${s}Zero"

show "c + d = " [add $c $d]

show "a + b + d = " [add $a [add $b $d]]

{{out}}

<pre>