Add reverse operator methods

Author: Kevin D Smith

swat/cas/table.py

@@ -9254,48 +9254,72 @@ def radd(self, other, level=None, fill_value=None, axis=0):
                                  add_length=True)
         return self._compute('radd', '({other}) + ({value})', other=other)
 
+    def __radd__(self, other):
+        return self.radd(other)
+
     def rsub(self, other, level=None, fill_value=None, axis=0):
         ''' Subtraction of CASColumn and other, element-wise '''
         if self._is_character():
             raise AttributeError('rsub')
         return self._compute('rsub', '({other}) - ({value})', other=other)
 
+    def __rsub__(self, other):
+        return self.rsub(other)
+
     def rmul(self, other, level=None, fill_value=None, axis=0):
         ''' Multiplication of CASColumn and other, element-wise '''
         if self._is_character():
             return self.str.repeat(other)
         return self._compute('rmul', '({other}) * ({value})', other=other)
 
+    def __rmul__(self, other):
+        return self.rmul(other)
+
     def rdiv(self, other, level=None, fill_value=None, axis=0):
         ''' Floating division of CASColumn and other, element-wise '''
         if self._is_character():
             raise AttributeError('rdiv')
         return self._compute('rdiv', '({other}) / ({value})', other=other)
 
+    def __rdiv__(self, other):
+        return self.rdiv(other)
+
     def rtruediv(self, other, level=None, fill_value=None, axis=0):
         ''' Floating division of CASColumn and other, element-wise '''
         if self._is_character():
             raise AttributeError('rtruediv')
         return self._compute('rtruediv', '({other}) / ({value})', other=other)
 
+    def __rtruediv__(self, other):
+        return self.rtruediv(other)
+
     def rfloordiv(self, other, level=None, fill_value=None, axis=0):
         ''' Integer division of CASColumn and other, element-wise '''
         if self._is_character():
             raise AttributeError('floordiv')
         return self._compute('div', 'floor(({other}) / ({value}))', other=other)
 
+    def __rfloordiv__(self, other):
+        return self.rfloordiv(other)
+
     def rmod(self, other, level=None, fill_value=None, axis=0):
         ''' Modulo of CASColumn and other, element-wise '''
         if self._is_character():
             raise AttributeError('rmod')
         return self._compute('rmod', 'mod({other}, {value})', other=other)
 
+    def __rmod__(self, other):
+        return self.rmod(other)
+
     def rpow(self, other, level=None, fill_value=None, axis=0):
         ''' Exponential power of CASColumn and other, element-wise '''
         if self._is_character():
             raise AttributeError('rpow')
         return self._compute('rpow', '({other})**({value})', other=other)
 
+    def __rpow__(self, other):
+        return self.rpow(other)
+
     def round(self, decimals=0, out=None):
         ''' Round each value of the CASColumn to the given number of decimals '''
         if self._is_character():

swat/tests/cas/test_table.py

@@ -2714,6 +2714,8 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
         tblout = (tbl['MSRP'].pow(-tbl['EngineSize']/10))
         assertItemsAlmostEqual(dfout, tblout, 2)
 
+        self.assertColsEqual(123.45 + df['MSRP'], 123.45 + tbl['MSRP'])
+        self.assertColsEqual(-123.45 + df['MSRP'], -123.45 + tbl['MSRP'])
         self.assertColsEqual((df['MSRP'].radd(123.45)),
                            (tbl['MSRP'].radd(123.45)))
         self.assertColsEqual((df['MSRP'].radd(-123.45)),
@@ -2724,6 +2726,8 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
         self.assertColsEqual((df['MSRP'].radd(-df['EngineSize'])),
                            (tbl['MSRP'].radd(-tbl['EngineSize'])))
 
+        self.assertColsEqual(123.45 - df['MSRP'], 123.45 - tbl['MSRP'])
+        self.assertColsEqual(-123.45 - df['MSRP'], -123.45 - tbl['MSRP'])
         self.assertColsEqual((df['MSRP'].rsub(123.45)),
                            (tbl['MSRP'].rsub(123.45)))
         self.assertColsEqual((df['MSRP'].rsub(-123.45)),
@@ -2734,6 +2738,8 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
         self.assertColsEqual((df['MSRP'].rsub(-df['EngineSize'])),
                            (tbl['MSRP'].rsub(-tbl['EngineSize'])))
 
+        assertItemsAlmostEqual(123.45 * df['MSRP'],  123.45 * tbl['MSRP'])
+        assertItemsAlmostEqual(-123.45 * df['MSRP'], -123.45 * tbl['MSRP'])
         assertItemsAlmostEqual((df['MSRP'].rmul(123.45)),
                                (tbl['MSRP'].rmul(123.45)))
         assertItemsAlmostEqual((df['MSRP'].rmul(-123.45)),
@@ -2744,6 +2750,8 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
         assertItemsAlmostEqual((df['MSRP'].rmul(-df['EngineSize'])),
                                (tbl['MSRP'].rmul(-tbl['EngineSize'])))
 
+        assertItemsAlmostEqual(123.45 / df['MSRP'], 123.45 / tbl['MSRP'])
+        assertItemsAlmostEqual(-123.45 / df['MSRP'], -123.45 / tbl['MSRP'])
         assertItemsAlmostEqual((df['MSRP'].rdiv(123.45)),
                                (tbl['MSRP'].rdiv(123.45)))
         assertItemsAlmostEqual((df['MSRP'].rdiv(-123.45)),
@@ -2752,6 +2760,9 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
                                (tbl['MSRP'].rtruediv(123.45)))
         assertItemsAlmostEqual((df['MSRP'].rtruediv(-123.45)),
                                (tbl['MSRP'].rtruediv(-123.45)))
+
+        assertItemsAlmostEqual(123.45 // df['MSRP'], 123.45 // tbl['MSRP'])
+        assertItemsAlmostEqual(-123.45 // df['MSRP'], -123.45 // tbl['MSRP'])
         assertItemsAlmostEqual((df['MSRP'].rfloordiv(123.45)),
                                (tbl['MSRP'].rfloordiv(123.45)))
         assertItemsAlmostEqual((df['MSRP'].rfloordiv(-123.45)),
@@ -2770,6 +2781,10 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
         assertItemsAlmostEqual((df['MSRP'].rfloordiv(-df['EngineSize'])),
                                (tbl['MSRP'].rfloordiv(-tbl['EngineSize'])))
 
+        dfout = (123.45 % df['MSRP'])
+        tblout = (123.45 % tbl['MSRP'])
+        assertItemsAlmostEqual(dfout, tblout, 4)
+
         dfout = (df['MSRP'].rmod(123.45))
         tblout = (tbl['MSRP'].rmod(123.45))
         assertItemsAlmostEqual(dfout, tblout, 4)
@@ -2788,6 +2803,10 @@ def assertItemsAlmostEqual(list1, list2, decimals=4):
         for dfo, tblo in zip(sorted(dfout), sorted(tblout)):
             self.assertAlmostEqual(dfo, tblo, 4)
 
+        dfout = (0.12345 ** df['MSRP'])
+        tblout = (0.12345 ** tbl['MSRP'])
+        assertItemsAlmostEqual(dfout, tblout, 4)
+
         dfout = (df['MSRP'].rpow(0.12345))
         tblout = (tbl['MSRP'].rpow(0.12345))
         assertItemsAlmostEqual(dfout, tblout, 4)
@@ -2889,6 +2908,9 @@ def test_character_operators(self):
         with self.assertRaises(AttributeError):
             tbl['Make'].pow(tbl['Model'])
 
+        self.assertColsEqual('Foo' + df['Make'], 'Foo' + tbl['Make'])
+        self.assertColsEqual((df['Make'].radd(df['Model'].str.strip())),
+                           (tbl['Make'].radd(tbl['Model'].str.strip())))
         self.assertColsEqual((df['Make'].radd('Foo')),
                            (tbl['Make'].radd('Foo')))
         self.assertColsEqual((df['Make'].radd(df['Model'].str.strip())),
@@ -2899,6 +2921,7 @@ def test_character_operators(self):
         with self.assertRaises(AttributeError):
             tbl['Make'].rsub(tbl['Model'])
 
+        self.assertColsEqual(3 * df['Make'], 3 * tbl['Make'])
         self.assertColsEqual((df['Make'].rmul(3)),
                            (tbl['Make'].rmul(3)))
         self.assertColsEqual((df['Make'].rmul(df['EngineSize'].astype('int'))),