finitefields 0.0.8 → 0.0.9

package/ellipticcurves.ts

@@ -8,12 +8,15 @@
  */
 
 import type { GF,PrimeField } from './galois.js';
+import { just, nothing, type Maybe, type Nothing } from './maybe.js';
 import { Util } from './galois.js';
 
+let 𝒪:Nothing;
 let log:(...x:any[])=>void;
 let fail:(...x:any[])=>never;
 let p256:()=>ECCurve;
 
+𝒪 = nothing();
 log = console.log;
 fail = (...args:any[]): never => {
     console.error(...args);
@@ -45,6 +48,7 @@ p256 = ():ECCurve => ({
 });
 
 type Tuple<a> = readonly [a,a];
+type Coordinate = Maybe<Point>;
 type infinity = false | true;
 type ECformula = (a:bigint,b:bigint,f:GF)=>Function;
 
@@ -66,6 +70,8 @@ interface ECCurve extends IECCurve,Tuples,hashE {};
 interface Iellipticcurves<a> {
     backend: a;
     constructor:Function;
+    add:(a:Coordinate,b:Coordinate)=>Coordinate;
+    double:(a:Coordinate)=>Coordinate;
 }
 
 interface Icurve extends IECCurve {
@@ -138,6 +144,32 @@ abstract class EllipticCurves<a> implements Iellipticcurves<a> {
     public abstract backend: a;
     private curve: Curve<a>;
 
+    protected addpoints(a:Coordinate,b:Coordinate): Coordinate {
+        return a;
+    }
+
+    protected doublepoint(a:Coordinate): Coordinate {
+        return a;
+    }
+
+    public add(a:Coordinate,b:Coordinate): Coordinate {
+        if ((a === 𝒪) && (b === 𝒪))
+            return <Maybe<Point>>nothing();
+        else if (a === 𝒪)
+            return <Maybe<Point>>just(b as unknown as Point);
+        else if (b === 𝒪)
+            return <Maybe<Point>>just(a as unknown as Point);
+        else
+            return <Maybe<Point>>this.addpoints(a,b);
+    }
+
+    public double(a:Coordinate): Coordinate {
+        if (a === 𝒪)
+            return nothing();
+        else
+            return this.doublepoint(a);
+    }
+
     constructor(curve:ECCurve) {
         this.curve = new Curve<a>(curve);
 

package/galois.ts

@@ -146,8 +146,8 @@ Util = {
         let a:bigint;
         let e:bigint;
 
-        sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
-        log(`${a_}${sign}${e_} (mod ${p}) = `);
+        // sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
+        // log(`${a_}${sign}${e_} (mod ${p}) = `);
 
         switch (method) {
             case methods.SquareAndMultiply:
@@ -161,10 +161,8 @@ Util = {
 
             case methods.DoubleAndAdd:
                 sq  = (y:bigint,p_:bigint):bigint           =>
-                    // Util.binmethod(y,2n,p_,DoubleAndAdd)
                     ((y+y)%p_)
                 mul = (y:bigint,z:bigint,p_:bigint):bigint  =>
-                    // Util.binmethod(y,z,p_,DoubleAndAdd)
                     ((y+z)%p_);
                 a=e_;
                 e=a_;
@@ -184,18 +182,13 @@ Util = {
             .fill(false,0,Number(bitlen))
             .map((x:boolean,idx:number):boolean =>
                 (((e>>n--)&1n)===1n) && (!!idx));
-        // if (method === methods.DoubleAndAdd)
-            bitstring.shift();
+        bitstring.shift();
         // log(bitstring.map((x:boolean):number => (x)?1:0));
         bitstring
             .forEach((x:boolean):void => {
-                // val = (x) ?
-                //     mul(a,sq(val,p),p) :
-                // sq(a,p);
                 val = (x) ?
                     mul(a,sq(val,p),p) :
                 sq(val,p);
-                // log(val);
                 
                 return void 0;
             });

package/main.ts

@@ -2,16 +2,22 @@
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
 import { ecℤp, p256 } from './ellipticcurves.js';
+import { empty, fold, just, nothing } from './maybe.js';
+import type { Maybe, Just, Nothing } from './maybe.js';
 
 let log:(...x:any[])=>void;
 log = console.log;
 
-let field:PrimeField;
-let curve:ecℤp;
+let foo:Maybe<string>;
+foo = just(1..toString());
+log(empty(foo));
 
-field = new PrimeField(p256().θ, p256().bitlen);
-log(field);
-curve = new ecℤp(field, p256());
-log(curve);
+// let field:PrimeField;
+// let curve:ecℤp;
+
+// field = new PrimeField(p256().θ, p256().bitlen);
+// log(field);
+// curve = new ecℤp(field, p256());
+// log(curve);
 
 export { Polynomial,Util,PrimeField,ecℤp,p256 };

package/maybe.ts

@@ -0,0 +1,40 @@
+/*
+ * maybe datatype
+ *
+ * finitefields package by @dr-Jonas-Birch
+ *
+ * 2026
+ *
+ */
+
+let log:(...args:any[])=>void;
+let fail:(...args:any[])=>never;
+
+log = console.log;
+fail = (...args:any[]): never => {
+    console.error(...args);
+    throw new Error(args.toString());
+
+    return void 0 as never;
+}
+
+type Nothing = readonly [];
+type Just<a> = readonly [a];
+type Maybe<a> =
+    | Nothing
+    | Just<a>;
+
+let empty:<a>(x:Maybe<a>)=>boolean;
+let nothing:()=>Nothing;
+let just:<a>(x:a)=>Just<a>;
+let fold:<a>(x:Maybe<a>)=>a|never;
+let x:Function;
+
+nothing = (): Nothing => [] as Nothing;
+just = <a>(x:a): Just<a> => [x] as Just<a>;
+empty = <a>(x:Maybe<a>): x is Nothing => !(x&&x.length);
+fold = <a>(x:Maybe<a>): a|never =>
+    (!empty(x))?x[0] as a:fail("folding nothing") as never;
+
+export type { Maybe, Just, Nothing };
+export { nothing, just, empty, fold };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "finitefields",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Galois/Finite field crypto and raw elliptic curves",
   "main": "main.js",
   "scripts": {