Complete mpc.np_divide().

mpyc/__init__.py

@@ -29,7 +29,7 @@
 and statistics (securely mimicking Python’s statistics module).
 """
 
-__version__ = '0.9.9'
+__version__ = '0.9.10'
 __license__ = 'MIT License'
 
 import os
@@ -170,10 +170,10 @@ def get_arg_parser():
     if importlib.util.find_spec('winloop' if sys.platform.startswith('win32') else 'uvloop'):
         # uvloop (winloop) package available
         if options.no_uvloop or env_no_uvloop:
-            logging.info(f'Use of package uvloop (winloop) inside MPyC disabled.')
+            logging.info('Use of package uvloop (winloop) inside MPyC disabled.')
         elif sys.platform.startswith('win32'):
             from winloop import EventLoopPolicy
-            logging.debug(f'Load winloop')
+            logging.debug('Load winloop')
         else:
             from uvloop import EventLoopPolicy, _version
             logging.debug(f'Load uvloop version {_version.__version__}')

mpyc/runtime.py

@@ -1115,8 +1115,6 @@ def div(self, a, b):
         if f:
             if isinstance(b, (int, float)):
                 c = 1/b
-                if c.is_integer():
-                    c = round(c)
             else:
                 c = b.reciprocal() << f
         else:
@@ -1140,17 +1138,15 @@ def np_divide(self, a, b):
 
         # isinstance(a, self.SecureArray) ensured
         if f:
-            if isinstance(b, (int, float)):
+            if isinstance(b, (int, float, np.ndarray)):
                 c = 1/b
-                if c.is_integer():
-                    c = round(c)
             elif isinstance(b, self.SecureFixedPoint):
                 c = self._rec(b)
             else:
                 c = b.reciprocal() << f
         else:
             if not isinstance(b, field.array):
-                b = field.array(b)  # TODO: see if this can be used for case f != 0 as well
+                b = field.array(b)
             c = b.reciprocal()
         return self.np_multiply(a, c)
 

mpyc/sectypes.py

@@ -56,6 +56,9 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
             if op == operator.sub:
                 return inputs[1].__rsub__(inputs[0])
 
+            if op == operator.truediv:
+                return inputs[1].__rtruediv__(inputs[0])
+
             return op(inputs[1], inputs[0])
 
         if op := unary_ops.get(ufunc):

tests/test_runtime.py

@@ -238,6 +238,7 @@ def __lt__(self, other):
     @unittest.skipIf(not np, 'NumPy not available or inside MPyC disabled')
     def test_secfxp_array(self):
         np.assertEqual = np.testing.assert_array_equal
+        np.assertAlmostEqual = np.testing.assert_allclose
 
         secfxp = mpc.SecFxp(12)
         a = np.array([[-1.5, 2.5], [4.5, -8.5]])
@@ -252,6 +253,8 @@ def test_secfxp_array(self):
         np.assertEqual(mpc.run(mpc.output(c * np.array([1.5, 2.5]))), a * np.array([1.5, 2.5]))
         np.assertEqual(mpc.run(mpc.output(c * secfxp(2.5))), a * 2.5)
         np.assertEqual(mpc.run(mpc.output(c * 2.5)), a * 2.5)
+        np.assertEqual(mpc.run(mpc.output(c / secfxp.field(2))), a / 2)
+        np.assertEqual(mpc.run(mpc.output(c / secfxp.field.array([2]))), a / 2)
 
         # NB: NumPy dispatcher converts np.int8 to int
         np.assertEqual(mpc.run(mpc.output(c * np.int8(2))), a * 2)
@@ -278,10 +281,17 @@ def test_secfxp_array(self):
         f = 32
         secfxp = mpc.SecFxp(2*f)
         c = secfxp.array(a)
-        np.testing.assert_allclose(mpc.run(mpc.output(c / 2.45)), a / 2.45, rtol=0, atol=2**(1-f))
-        np.testing.assert_allclose(mpc.run(mpc.output(c / 2.5)), a / 2.5, rtol=0, atol=2**(2-f))
-        np.testing.assert_allclose(mpc.run(mpc.output(1 / c)), 1 / a, rtol=0, atol=2**(1-f))
-        np.testing.assert_allclose(mpc.run(mpc.output(c / c)), 1, rtol=0, atol=2**(3-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(c / 0.5)), a / 0.5, rtol=0, atol=0)
+        np.assertAlmostEqual(mpc.run(mpc.output(c / 2.45)), a / 2.45, rtol=0, atol=2**(1-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(c / 2.5)), a / 2.5, rtol=0, atol=2**(2-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(c / c[0, 1])), a / 2.5, rtol=0, atol=2**(3-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(1 / c)), 1 / a, rtol=0, atol=2**(1-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(secfxp(1.5) / c)), 1.5 / a, rtol=0, atol=2**(1-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(1.5 / c)), 1.5 / a, rtol=0, atol=2**(1-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(a / c)), 1, rtol=0, atol=2**(3-f))
+        np.assertAlmostEqual(mpc.run(mpc.output((2*a).astype(int) / c)), 2, rtol=0, atol=2**(4-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(c / a)), 1, rtol=0, atol=2**(0-f))
+        np.assertAlmostEqual(mpc.run(mpc.output(c / c)), 1, rtol=0, atol=2**(3-f))
         np.assertEqual(mpc.run(mpc.output(np.equal(c, c))), True)
         np.assertEqual(mpc.run(mpc.output(np.equal(c, 0))), False)
         np.assertEqual(mpc.run(mpc.output(np.sum(c, axis=(-2, 1)))), np.sum(a, axis=(-2, 1)))
@@ -824,6 +834,7 @@ def test_secfxp(self):
             self.assertAlmostEqual(mpc.run(mpc.output(c / d)), t, delta=2**(3-f))
             t = -s[3] / s[2]
             self.assertAlmostEqual(mpc.run(mpc.output(-d / c)), t, delta=2**(3-f))
+            self.assertEqual(mpc.run(mpc.output(secfxp(2) / secfxp.field(2))), 1)
 
             self.assertEqual(mpc.run(mpc.output(mpc.sgn(+a))), s[0] > 0)
             self.assertEqual(mpc.run(mpc.output(mpc.sgn(-a))), -(s[0] > 0))