Merge pull request #620 from liboyue/Add_fmod_remainder_and_remove_mod

Add fmod(), remainder(), remove mod() and fix tensor operator % behavior

1 files changed, 94 insertions, 13 deletions

diff --git a/test/test.lua b/test/test.lua
index 87f46b2..fe197c0 100644
--- a/test/test.lua
+++ b/test/test.lua
@@ -701,12 +701,29 @@ function torchtest.div()
    mytester:assertlt(err, precision, 'error in torch.div - scalar, non contiguous')
 end
 
-function torchtest.mod()
-   local m1 = torch.Tensor(10,10):uniform(10)
+function torchtest.fmod()
+   local m1 = torch.Tensor(10,10):uniform(-10, 10)
    local res1 = m1:clone()
 
    local q = 2.1
-   res1[{ {},3 }]:mod(q)
+   res1[{ {},3 }]:fmod(q)
+
+   local res2 = m1:clone()
+   for i = 1,m1:size(1) do
+      res2[{ i,3 }] = math.fmod(res2[{ i,3 }], q)
+   end
+
+   local err = (res1-res2):abs():max()
+
+   mytester:assertlt(err, precision, 'error in torch.fmod - scalar, non contiguous')
+end
+
+function torchtest.remainder()
+   local m1 = torch.Tensor(10, 10):uniform(-10, 10)
+   local res1 = m1:clone()
+
+   local q = 2.1
+   res1[{ {},3 }]:remainder(q)
 
    local res2 = m1:clone()
    for i = 1,m1:size(1) do
@@ -715,7 +732,7 @@ function torchtest.mod()
 
    local err = (res1-res2):abs():max()
 
-   mytester:assertlt(err, precision, 'error in torch.mod - scalar, non contiguous')
+   mytester:assertlt(err, precision, 'error in torch.remainder - scalar, non contiguous')
 end
 
 function torchtest.mm()
@@ -1034,13 +1051,77 @@ function torchtest.cdiv()  -- [res] torch.cdiv([res,] tensor1, tensor2)
    mytester:assertlt(maxerr, precision, 'error in torch.cdiv - non-contiguous')
 end
 
-function torchtest.cmod()  -- [res] torch.cmod([res,] tensor1, tensor2)
+function torchtest.cfmod()
+   -- contiguous
+   local m1 = torch.Tensor(10, 10, 10):uniform(-10, 10)
+   local m2 = torch.Tensor(10, 10 * 10):uniform(-3, 3)
+   local sm1 = m1[{4, {}, {}}]
+   local sm2 = m2[{4, {}}]
+   local res1 = torch.cfmod(sm1, sm2)
+   local res2 = res1:clone():zero()
+   for i = 1,sm1:size(1) do
+      for j = 1, sm1:size(2) do
+         local idx1d = (((i-1)*sm1:size(1)))+j
+         res2[i][j] = math.fmod(sm1[i][j], sm2[idx1d])
+      end
+   end
+   local err = res1:clone():zero()
+   -- find absolute error
+   for i = 1, res1:size(1) do
+      for j = 1, res1:size(2) do
+         err[i][j] = math.abs(res1[i][j] - res2[i][j])
+      end
+   end
+   -- find maximum element of error
+   local maxerr = 0
+   for i = 1, err:size(1) do
+      for j = 1, err:size(2) do
+         if err[i][j] > maxerr then
+            maxerr = err[i][j]
+         end
+      end
+   end
+   mytester:assertlt(maxerr, precision, 'error in torch.cfmod - contiguous')
+
+   -- non-contiguous
+   local m1 = torch.Tensor(10, 10, 10):uniform(-10, 10)
+   local m2 = torch.Tensor(10 * 10, 10 * 10):uniform(-3, 3)
+   local sm1 = m1[{{}, 4, {}}]
+   local sm2 = m2[{{}, 4}]
+   local res1 = torch.cfmod(sm1, sm2)
+   local res2 = res1:clone():zero()
+   for i = 1,sm1:size(1) do
+      for j = 1, sm1:size(2) do
+         local idx1d = (((i-1)*sm1:size(1)))+j
+         res2[i][j] = math.fmod(sm1[i][j], sm2[idx1d])
+      end
+   end
+   local err = res1:clone():zero()
+   -- find absolute error
+   for i = 1, res1:size(1) do
+      for j = 1, res1:size(2) do
+         err[i][j] = math.abs(res1[i][j] - res2[i][j])
+      end
+   end
+   -- find maximum element of error
+   local maxerr = 0
+   for i = 1, err:size(1) do
+      for j = 1, err:size(2) do
+         if err[i][j] > maxerr then
+            maxerr = err[i][j]
+         end
+      end
+   end
+   mytester:assertlt(maxerr, precision, 'error in torch.cfmod - non-contiguous')
+end
+
+function torchtest.cremainder()
    -- contiguous
-   local m1 = torch.Tensor(10, 10, 10):uniform(10)
-   local m2 = torch.Tensor(10, 10 * 10):uniform(3)
+   local m1 = torch.Tensor(10, 10, 10):uniform(-10, 10)
+   local m2 = torch.Tensor(10, 10 * 10):uniform(-3, 3)
    local sm1 = m1[{4, {}, {}}]
    local sm2 = m2[{4, {}}]
-   local res1 = torch.cmod(sm1, sm2)
+   local res1 = torch.cremainder(sm1, sm2)
    local res2 = res1:clone():zero()
    for i = 1,sm1:size(1) do
       for j = 1, sm1:size(2) do
@@ -1064,14 +1145,14 @@ function torchtest.cmod()  -- [res] torch.cmod([res,] tensor1, tensor2)
          end
       end
    end
-   mytester:assertlt(maxerr, precision, 'error in torch.cmod - contiguous')
+   mytester:assertlt(maxerr, precision, 'error in torch.cremainder - contiguous')
 
    -- non-contiguous
-   local m1 = torch.Tensor(10, 10, 10):uniform(10)
-   local m2 = torch.Tensor(10 * 10, 10 * 10):uniform(3)
+   local m1 = torch.Tensor(10, 10, 10):uniform(-10, 10)
+   local m2 = torch.Tensor(10 * 10, 10 * 10):uniform(-3, 3)
    local sm1 = m1[{{}, 4, {}}]
    local sm2 = m2[{{}, 4}]
-   local res1 = torch.cmod(sm1, sm2)
+   local res1 = torch.cremainder(sm1, sm2)
    local res2 = res1:clone():zero()
    for i = 1,sm1:size(1) do
       for j = 1, sm1:size(2) do
@@ -1095,7 +1176,7 @@ function torchtest.cmod()  -- [res] torch.cmod([res,] tensor1, tensor2)
          end
       end
    end
-   mytester:assertlt(maxerr, precision, 'error in torch.cmod - non-contiguous')
+   mytester:assertlt(maxerr, precision, 'error in torch.cremainder - non-contiguous')
 end
 
 function torchtest.cmul()  -- [res] torch.cmul([res,] tensor1, tensor2)