Elliptic curve arithmetic: Difference between revisions

<br>for any point '''P''' and integer '''n''', &nbsp; the point '''P + P + ... + P''' &nbsp; &nbsp; ('''n''' times).

<br><br>

 

=={{header|C}}==

#include <math.h>

 

 

return 0;

{{out}}

<pre>

=={{header|C++}}==

Uses C++11 or later

#include <iostream>

 

return 0;

 

{{out}}

=={{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)

=={{header|Haskell}}==

First, some useful imports:

import Control.Monad (guard)

 

The datatype for a point on an elliptic curve:

 

 

data Elliptic = Elliptic Double Double | Zero

 

inv Zero = Zero

 

Points on elliptic curve form a monoid:

mempty = Zero

 

mkElliptic l = let x = l^2 - x1 - x2

y = l*(x1 - x) - y1

 

Examples given in other solutions:

 

 

<pre>λ> let a = ellipticX 7 1

 

1. direct monoidal solution:

 

2. efficient recursive solution:

| n == 0 = Zero

| n == 1 = p

| n < 0 = inv ((-n) `mult` p)

| even n = 2 `mult` ((n `div` 2) `mult` p)

 

<pre>λ> 12345 `mult` a

We use QuickCheck to test general properties of points on arbitrary elliptic curve.

 

elliptic a b Nothing = Just Zero

elliptic a b (Just x) =

commutativity a b x1 x2 =

let p = elliptic a b

 

<pre>λ> quickCheck addition

Follows the C contribution.

 

isZero=: 1e20 < |@{.@+.

echo 'a + b + d = ', show add/ a, b, d

echo 'a * 12345 = ', show a mul 12345

{{out}}

a = (_1.81712, 1)

b = (_1.44225, 2)

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|Julia}}==

{{trans|Python}}

 

x::T

y::T

@show c + d

@show a + b + d

 

{{out}}

===Julia 1.x compatible version===

Adds assertion checks for points to be on the curve.

using Printf

import Base.in

@show a + b + d

@show 12345a

Output: Same as the original, Julia 0.6 version code.

 

=={{header|Kotlin}}==

{{trans|C}}

 

const val C = 7

println("a + b + d = ${a + b + d}")

println("a * 12345 = ${a * 12345}")

 

{{out}}

=={{header|Nim}}==

{{trans|C}}

 

const B = 7

echo "c + d = ", c + d

echo "a + b + d = ", a + b + d

 

{{out}}

Original version by [http://rosettacode.org/wiki/User:Vanyamil User:Vanyamil].

Some float-precision issues but overall works.

(* Task : Elliptic_curve_arithmetic *)

 

print_output ();

print_output ()

{{out}}

<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}}

{

our ($A, $B) = (0, 7);

print "check alignment... ";

print abs(($q->x - $p->x)*(-$s->y - $p->y) - ($q->y - $p->y)*($s->x - $p->x)) < 0.001

{{out}}

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

=={{header|Phix}}==

{{Trans|C}}

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(load "@lib/math.l")

(setq *B 7)

(prinl "D + C: " (prn (add C D)))

(prinl "A + B + D: " (prn (add A (add B D))))

{{out}}

<pre>

=={{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|Raku}}==

(formerly Perl 6)

 

has ($.x, $.y);

multi method new(

 

 

 

my $l = (3*$p.x**2 + $A) / (2 *$p.y);

my $y = $l*($p.x - my $x = $l**2 - 2*$p.x) - $p.y;

2 * ($n div 2 * $p) + $n % 2 * $p;

 

if $p.x ~~ $q.x {

}

else {

}

}

 

say my $s = $p + $q;

 

{{out}}

<pre>EC Point at x=1, y=2.8284271247461903

EC Point at x=2, y=3.872983346207417

EC Point at x=-1.9089023002066448, y=0.21008487055753378

 

=={{header|REXX}}==

 

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

numeric digits 100 /*try to ensure a min. of accuracy loss*/

a= func(1) ; say ' a = ' show(a)

do until d==a; d=min(d+d,a); numeric digits d; o=0

do until o=g; o=g; g=format((m*g**y+x)/y/g**m,,d-2); end /*until o=g*/

{{out|output}}

<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>

=={{header|Sidef}}==

{{trans|Raku}}

 

var A = 0

say var s = (p + q)

 

{{out}}

<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>

{{trans|C}}

{{libheader|Wren-fmt}}

 

var C = 7

y { _y }

 

 

isZero { x > 1e20 || x < -1e20 }

System.print("c + d = %(c + d)")

System.print("a + b + d = %(a + b + d)")

 

{{out}}

c + d = Zero

a + b + d = Zero

</pre>

 

=={{header|zkl}}==

{{trans|C}}

 

fcn zero{ T(INFINITY, INFINITY) }

}

r

{ println(str, is_zero(p) and "Zero" or "(%.3f, %.3f)".fmt(p.xplode())) }

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

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

{{out}}

<pre>