Elliptic curve arithmetic: Difference between revisions

{{trans|Python}}

Float x, y

show(‘c + d =’, c.add(d))

show(‘a + b + d =’, a.add(b.add(d)))

{{out}}

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

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">X</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">Y</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">bCoeff</span><span style="color: #0000FF;">=</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">INF</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1e300</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1e300</span>

<span style="color: #000000;">show</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"a + b + d = "</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">)))</span>

<span style="color: #000000;">show</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"a * 12345 = "</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">12345</span><span style="color: #0000FF;">))</span>

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

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

say my $s = $p + $q;

{{out}}

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

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

print('S = P + Q',S)

print('P+Q-S', P+Q-S)

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

=={{header|Vlang}}==

{{trans|go}}

const b_coeff = 7

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

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

{{out}}

{{trans|C}}

{{libheader|Wren-fmt}}

var C = 7

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

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

{{out}}

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