Feature/major rescaling (#19)

Majorly change redesign of rational interface

Author: mathias-nillion

.github/workflows/test.yml

@@ -21,7 +21,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install black
+        pip install black[jupyter]
     - name: Check linting
       run: black --check .  
       # If PR fails in this stage, it's because of linting issues: run `black .` to fix them

examples/broadcasting/src/broadcasting.py

@@ -9,16 +9,16 @@ def nada_main():
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3, ) with name "A"
-    a = na.array([3], parties[0], "A")
+    a = na.array([3], parties[0], "A", SecretInteger)
 
     # Step 3: Party1 creates an array of dimension (3, ) with name "B"
-    b = na.array([3], parties[1], "B")
+    b = na.array([3], parties[1], "B", SecretInteger)
 
     # Step 4: Party0 creates an array of dimension (3, ) with name "C"
-    c = na.array([3], parties[0], "C")
+    c = na.array([3], parties[0], "C", SecretInteger)
 
     # Step 5: Party1 creates an array of dimension (3, ) with name "D"
-    d = na.array([3], parties[1], "D")
+    d = na.array([3], parties[1], "D", SecretInteger)
 
     # Step 4: The result is of computing SIMD operations on top of the elements of the array
     # SIMD operations are performed on all the elements of the array.

examples/dot_product/src/dot_product.py

@@ -9,10 +9,10 @@ def nada_main():
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3, ) with name "A"
-    a = na.array([3], parties[0], "A")
+    a = na.array([3], parties[0], "A", SecretInteger)
 
     # Step 3: Party1 creates an array of dimension (3, ) with name "B"
-    b = na.array([3], parties[1], "B")
+    b = na.array([3], parties[1], "B", SecretInteger)
 
     # Step 4: The result is of computing the dot product between the two
     result = a.dot(b)

examples/matrix_multiplication/src/matrix_multiplication.py

@@ -9,10 +9,10 @@ def nada_main():
     parties = na.parties(3)
 
     # Step 2: Party0 creates an array of dimension (3 x 3) with name "A"
-    a = na.array([3, 3], parties[0], "A")
+    a = na.array([3, 3], parties[0], "A", SecretInteger)
 
     # Step 3: Party1 creates an array of dimension (3 x 3) with name "B"
-    b = na.array([3, 3], parties[1], "B")
+    b = na.array([3, 3], parties[1], "B", SecretInteger)
 
     # Step 4: The result is of computing the dot product between the two which is another (3 x 3) matrix
     result = a @ b

examples/rational_numbers/src/rational_numbers.py

@@ -7,13 +7,13 @@ def nada_main():
     parties = na.parties(3)
 
     # We use na.SecretRational to create a secret rational number for party 0
-    a = na.SecretRational("my_input_0", parties[0])
+    a = na.secret_rational("my_input_0", parties[0])
 
     # We use na.SecretRational to create a secret rational number for party 1
-    b = na.SecretRational("my_input_1", parties[1])
+    b = na.secret_rational("my_input_1", parties[1])
 
     # This is a compile time rational number
-    c = na.Rational(1.2)
+    c = na.rational(1.2)
 
     # The formula below does operations on rational numbers and returns a rational number
     # It's easy to see that (a + b - c) is both on numerator and denominator, so the end result is b

nada_algebra/__init__.py

@@ -1,5 +1,14 @@
 """This is the __init__.py module"""
 
 from nada_algebra.array import NadaArray
-from nada_algebra.types import RationalConfig, Rational, SecretRational
 from nada_algebra.funcs import *
+from nada_algebra.types import (
+    Rational,
+    SecretRational,
+    public_rational,
+    rational,
+    secret_rational,
+    get_log_scale,
+    reset_log_scale,
+    set_log_scale,
+)