Bugfix/client side rationals (#17)

Fix client-side rational logic

Author: mathias-nillion

nada_algebra/array.py

@@ -53,8 +53,8 @@ class NadaArray:
         "cumprod",
         "cumsum",
         "data",
-        "dtype",
         "diagonal",
+        "dtype",
         "fill",
         "flags",
         "flat",
@@ -64,11 +64,6 @@ class NadaArray:
         "itemsize",
         "nbytes",
         "ndim",
-        "diagonal",
-        "fill",
-        "flatten",
-        "item",
-        "itemset",
         "prod",
         "put",
         "ravel",
@@ -77,8 +72,8 @@ class NadaArray:
         "resize",
         "shape",
         "size",
-        "strides",
         "squeeze",
+        "strides",
         "sum",
         "swapaxes",
         "T",

nada_algebra/client.py

@@ -11,7 +11,7 @@
     PublicVariableUnsignedInteger,
 )
 import numpy as np
-from nada_algebra.types import RationalConfig, Rational, SecretRational
+from nada_algebra import types
 
 
 def parties(num: int, prefix: str = "Party") -> list:
@@ -36,8 +36,8 @@ def array(
         SecretUnsignedInteger,
         PublicVariableInteger,
         PublicVariableUnsignedInteger,
-        Rational,
-        SecretRational,
+        types.Rational,
+        types.SecretRational,
     ] = SecretInteger,
 ) -> dict:
     """
@@ -47,15 +47,35 @@ def array(
     Args:
         arr (np.ndarray): The input array.
         prefix (str): The prefix to be added to the output names.
-        nada_type (Union[type[SecretInteger], type[SecretUnsignedInteger], \
-            type[PublicVariableInteger], type[PublicVariableUnsignedInteger]], optional):
-            The type of the values introduced. Defaults to SecretInteger.
+        nada_type (type, optional): The type of the values introduced. Defaults to SecretInteger.
 
     Returns:
         dict: A dictionary mapping generated names to Nillion input objects.
     """
+    # TODO: remove check for zero values when pushing zero secrets is supported
     if len(arr.shape) == 1:
-        return {f"{prefix}_{i}": nada_type(int(arr[i])) for i in range(arr.shape[0])}
+        if nada_type == types.Rational:
+            return {
+                f"{prefix}_{i}": (PublicRational(arr[i])) for i in range(arr.shape[0])
+            }
+        if nada_type == types.SecretRational:
+            return {
+                f"{prefix}_{i}": (
+                    SecretRational(arr[i]) if arr[i] != 0 else SecretInteger(1)
+                )
+                for i in range(arr.shape[0])
+            }
+        return {
+            f"{prefix}_{i}": (
+                nada_type(int(arr[i]))
+                if (
+                    nada_type in (PublicVariableInteger, PublicVariableUnsignedInteger)
+                    or int(arr[i]) != 0
+                )
+                else nada_type(1)
+            )
+            for i in range(arr.shape[0])
+        }
     return {
         k: v
         for i in range(arr.shape[0])
@@ -88,7 +108,7 @@ def __rational(value: Union[float, int]) -> int:
     Returns:
         int: The integer representation of the input value.
     """
-    return round(value * (1 << RationalConfig.LOG_SCALE))
+    return round(value * (1 << types.RationalConfig.LOG_SCALE))
 
 
 def PublicRational(value: Union[float, int]) -> PublicVariableInteger:
@@ -104,13 +124,12 @@ def PublicRational(value: Union[float, int]) -> PublicVariableInteger:
     return PublicVariableInteger(__rational(value))
 
 
-def SecretRational(value: Union[float, int], party: str) -> SecretInteger:
+def SecretRational(value: Union[float, int]) -> SecretInteger:
     """
     Returns the integer representation of the given float value.
 
     Args:
         value (Union[float, int]): The input value.
-        party (str): The party name.
 
     Returns:
         int: The integer representation of the input value.

nada_algebra/types.py

@@ -9,17 +9,14 @@
     Integer,
     NadaType,
     SecretInteger,
-    SecretUnsignedInteger,
     SecretBoolean,
     PublicBoolean,
     PublicInteger,
-    PublicUnsignedInteger,
 )
-from typing import Any, Callable, Union
+from typing import Union
 
 
 _Number = Union[float, int, np.floating]
-_NadaSecretInteger = Union[SecretInteger]
 _NadaInteger = Union[
     Integer,
     PublicInteger,

tests/python-tests/test_client.py

@@ -0,0 +1,110 @@
+"""Nada algebra client unit tests"""
+
+import numpy as np
+import nada_algebra.client as na_client
+import nada_algebra as na
+import py_nillion_client as nillion
+
+
+class TestClient:
+
+    def test_array_1(self):
+        input_arr = np.random.randn(1)
+        nada_array = na_client.array(input_arr, "test")
+
+        assert list(nada_array.keys()) == ["test_0"]
+
+    def test_array_2(self):
+        input_arr = np.random.randn(1)
+        nada_array = na_client.array(input_arr, "test", na.Rational)
+
+        assert list(nada_array.keys()) == ["test_0"]
+
+    def test_array_3(self):
+        input_arr = np.random.randn(1)
+        nada_array = na_client.array(input_arr, "test", na.SecretRational)
+
+        assert list(nada_array.keys()) == ["test_0"]
+
+    def test_array_4(self):
+        input_arr = np.random.randn(1)
+        nada_array = na_client.array(input_arr, "test", nillion.PublicVariableInteger)
+
+        assert list(nada_array.keys()) == ["test_0"]
+
+    def test_array_5(self):
+        input_arr = np.random.randn(3)
+        nada_array = na_client.array(input_arr, "test")
+
+        assert list(nada_array.keys()) == ["test_0", "test_1", "test_2"]
+
+    def test_array_6(self):
+        input_arr = np.random.randn(2, 3)
+        nada_array = na_client.array(input_arr, "test")
+
+        assert list(sorted(nada_array.keys())) == [
+            "test_0_0",
+            "test_0_1",
+            "test_0_2",
+            "test_1_0",
+            "test_1_1",
+            "test_1_2",
+        ]
+
+    def test_array_7(self):
+        input_arr = np.array([])
+        nada_array = na_client.array(input_arr, "test")
+
+        assert nada_array == {}
+
+    def test_concat(self):
+        dict_1 = {"a": 1, "b": 2}
+        dict_2 = {"c": 3}
+
+        dict_comb = na_client.concat([dict_1, dict_2])
+
+        assert dict_comb == {"a": 1, "b": 2, "c": 3}
+
+    def test_secret_rational_1(self):
+        test_value = 1
+
+        rational = na_client.SecretRational(test_value)
+
+        assert isinstance(rational, nillion.SecretInteger)
+
+        rational_value = rational.value
+
+        assert rational_value == test_value * 2**na.types.RationalConfig.LOG_SCALE
+
+    def test_secret_rational_2(self):
+        test_value = 2.5
+
+        rational = na_client.SecretRational(test_value)
+
+        assert isinstance(rational, nillion.SecretInteger)
+
+        rational_value = rational.value
+
+        assert rational_value == test_value * 2**na.types.RationalConfig.LOG_SCALE
+
+    def test_public_rational_1(self):
+        test_value = 1
+
+        rational = na_client.PublicRational(test_value)
+
+        assert isinstance(rational, nillion.PublicVariableInteger)
+
+        rational_value = rational.value
+
+        assert rational_value == test_value * 2**na.types.RationalConfig.LOG_SCALE
+
+    def test_public_rational_2(self):
+        test_value = 2.5
+
+        rational = na_client.PublicRational(test_value)
+
+        assert isinstance(rational, nillion.PublicVariableInteger)
+
+        rational_value = rational.value
+
+        assert rational_value == test_value * 2**na.types.RationalConfig.LOG_SCALE

tests/test_all.py

@@ -114,11 +114,8 @@ def test_client():
 def test_rational_client():
     import nada_algebra.client as na_client  # For use with Python Client
     import py_nillion_client as nillion
-    import numpy as np
-
-    parties = na_client.parties(3)
 
-    secret_rational = na_client.SecretRational(3.2, parties[0])
+    secret_rational = na_client.SecretRational(3.2)
 
     assert type(secret_rational) == nillion.SecretInteger