from/as tests use rotation-array; separate bounds checks

python/tests/test_Rotation.py

@@ -7,6 +7,7 @@ from damask import Table
 from damask import _rotation
 from damask import grid_filters
 from damask import util
+from damask import tensor
 
 n = 1000
 atol=1.e-4
@@ -20,6 +21,16 @@ def ref_path(ref_path_base):
 def set_of_rotations(set_of_quaternions):
     return [Rotation.from_quaternion(s) for s in set_of_quaternions]
 
+@pytest.fixture
+def multidim_rotations(set_of_quaternions):
+    L = len(set_of_quaternions)
+    i = 0
+    while L%(f:=np.random.randint(2,np.sqrt(L).astype(int))) > 0 and i<L:
+        i += 1
+
+    f = i if i == L else f
+    return Rotation.from_quaternion(set_of_quaternions.reshape((L//f,f,-1)))
+
 
 ####################################################################################################
 # Code below available according to the following conditions
@@ -691,117 +702,156 @@ class TestRotation:
 
     def test_to_numpy(self):
         r = Rotation.from_random(np.random.randint(0,10,4))
-        assert np.all(r.as_quaternion() == np.array(r))
+        assert (r.as_quaternion() == np.array(r)).all()
 
-    @pytest.mark.parametrize('degrees',[True,False])
+    def test_bounds(self,multidim_rotations):
-    def test_Eulers(self,set_of_rotations,degrees):
+        m = multidim_rotations
-        for rot in set_of_rotations:
-            m = rot.as_quaternion()
-            o = Rotation.from_Euler_angles(rot.as_Euler_angles(degrees),degrees).as_quaternion()
-            ok = np.allclose(m,o,atol=atol)
-            if np.isclose(rot.as_quaternion()[0],0.0,atol=atol):
-                ok |= np.allclose(m*-1.,o,atol=atol)
-            assert ok and np.isclose(np.linalg.norm(o),1.0), f'{m},{o},{rot.as_quaternion()}'
 
-    @pytest.mark.parametrize('P',[1,-1])
+        q = m.as_quaternion()
-    @pytest.mark.parametrize('normalize',[True,False])
+        assert np.allclose(1.,np.linalg.norm(q,axis=-1))
-    @pytest.mark.parametrize('degrees',[True,False])
-    def test_axis_angle(self,set_of_rotations,degrees,normalize,P):
-        c = np.array([P*-1,P*-1,P*-1,1.])
-        c[:3] *= 0.9 if normalize else 1.0
-        for rot in set_of_rotations:
-            m = rot.as_Euler_angles()
-            o = Rotation.from_axis_angle(rot.as_axis_angle(degrees)*c,degrees,normalize,P).as_Euler_angles()
-            u = np.array([np.pi*2,np.pi,np.pi*2])
-            ok = np.allclose(m,o,atol=atol)
-            ok |= np.allclose(np.where(np.isclose(m,u),m-u,m),np.where(np.isclose(o,u),o-u,o),atol=atol)
-            if np.isclose(m[1],0.0,atol=atol) or np.isclose(m[1],np.pi,atol=atol):
-                sum_phi = np.unwrap([m[0]+m[2],o[0]+o[2]])
-                ok |= np.isclose(sum_phi[0],sum_phi[1],atol=atol)
-            assert ok and (np.zeros(3)-1.e-9 <= o).all() \
-                      and (o <= np.array([np.pi*2.,np.pi,np.pi*2.])+1.e-9).all(), f'{m},{o},{rot.as_quaternion()}'
 
-    def test_matrix(self,set_of_rotations):
+        v = m.as_Rodrigues_vector(compact=False)
-        for rot in set_of_rotations:
+        assert np.allclose(1.,np.linalg.norm(v[...,:3],axis=-1))
-            m = rot.as_axis_angle()
-            o = Rotation.from_axis_angle(rot.as_axis_angle()).as_axis_angle()
-            ok = np.allclose(m,o,atol=atol)
-            if np.isclose(m[3],np.pi,atol=atol):
-                ok |= np.allclose(m*np.array([-1.,-1.,-1.,1.]),o,atol=atol)
-            assert ok and np.isclose(np.linalg.norm(o[:3]),1.0) \
-                      and o[3]<=np.pi+1.e-9, f'{m},{o},{rot.as_quaternion()}'
 
-    def test_parallel(self,set_of_rotations):
+        v = m.as_axis_angle(degrees=False)
-        a = np.array([[1.0,0.0,0.0],
+        assert np.allclose(1.,np.linalg.norm(v[...,:3],axis=-1))
-                      [0.0,1.0,0.0]])
+        assert (v[...,3] >= 0.).all and (v < np.pi+1.e-9).all()
-        for rot in set_of_rotations:
-            assert rot.allclose(Rotation.from_parallel(a,rot.broadcast_to((2,))@a))
 
-    @pytest.mark.parametrize('P',[1,-1])
+        r = m.as_matrix()
-    @pytest.mark.parametrize('normalize',[True,False])
+        assert np.allclose(1.,np.linalg.det(r))
-    def test_Rodrigues(self,set_of_rotations,normalize,P):
-        c = np.array([P*-1,P*-1,P*-1,1.])
-        c[:3] *= 0.9 if normalize else 1.0
-        for rot in set_of_rotations:
-            m = rot.as_matrix()
-            o = Rotation.from_Rodrigues_vector(rot.as_Rodrigues_vector()*c,normalize,P).as_matrix()
-            ok = np.allclose(m,o,atol=atol)
-            assert ok and np.isclose(np.linalg.det(o),1.0), f'{m},{o}'
 
-    def test_Rodrigues_compact(self,set_of_rotations):
+        e = m.as_Euler_angles(degrees=False)
-        for rot in set_of_rotations:
+        assert (e >= 0.).all and (e < np.pi*np.array([2.,1.,2.])+1.e-9).all()
-            c = rot.as_Rodrigues_vector(compact=True)
+
-            r = rot.as_Rodrigues_vector(compact=False)
+        c = m.as_cubochoric()
-            assert np.allclose(r[:3]*r[3], c, equal_nan=True)
+        assert (np.linalg.norm(c,ord=np.inf,axis=-1) < np.pi**(2./3.)*0.5+1.e-9).all()
+
+        h = m.as_homochoric()
+        assert (np.linalg.norm(h,axis=-1) < (3.*np.pi/4.)**(1./3.) + 1.e-9).all()
 
 
-    @pytest.mark.parametrize('P',[1,-1])
-    def test_homochoric(self,set_of_rotations,P):
-        cutoff = np.tan(np.pi*.5*(1.-1e-4))
-        for rot in set_of_rotations:
-            m = rot.as_Rodrigues_vector()
-            o = Rotation.from_homochoric(rot.as_homochoric()*P*-1,P).as_Rodrigues_vector()
-            ok = np.allclose(np.clip(m,None,cutoff),np.clip(o,None,cutoff),atol=atol)
-            ok |= np.isclose(m[3],0.0,atol=atol)
-            assert ok and np.isclose(np.linalg.norm(o[:3]),1.0), f'{m},{o},{rot.as_quaternion()}'
-
-    @pytest.mark.parametrize('P',[1,-1])
-    def test_cubochoric(self,set_of_rotations,P):
-        for rot in set_of_rotations:
-            m = rot.as_homochoric()
-            o = Rotation.from_cubochoric(rot.as_cubochoric()*P*-1,P).as_homochoric()
-            ok = np.allclose(m,o,atol=atol)
-            assert ok and np.linalg.norm(o) < (3.*np.pi/4.)**(1./3.) + 1.e-9, f'{m},{o},{rot.as_quaternion()}'
-
-    @pytest.mark.parametrize('P',[1,-1])
     @pytest.mark.parametrize('accept_homomorph',[True,False])
     @pytest.mark.parametrize('normalize',[True,False])
-    def test_quaternion(self,set_of_rotations,P,accept_homomorph,normalize):
+    @pytest.mark.parametrize('P',[1,-1])
-        c = np.array([1,P*-1,P*-1,P*-1]) * (-1 if accept_homomorph else 1) * (0.9 if normalize else 1.0)
+    def test_quaternion(self,multidim_rotations,accept_homomorph,normalize,P):
-        for rot in set_of_rotations:
+        c = np.array([1,-P,-P,-P]) * (-1 if accept_homomorph else 1) * (0.9 if normalize else 1.0)
-            m = rot.as_cubochoric()
+        m = multidim_rotations
-            o = Rotation.from_quaternion(rot.as_quaternion()*c,accept_homomorph,normalize,P).as_cubochoric()
+        o = Rotation.from_quaternion(m.as_quaternion()*c,
-            ok = np.allclose(m,o,atol=atol)
+                                     accept_homomorph=accept_homomorph,
-            if np.count_nonzero(np.isclose(np.abs(o),np.pi**(2./3.)*.5)):
+                                     normalize=normalize,
-                ok |= np.allclose(m*-1.,o,atol=atol)
+                                     P=P)
-            assert ok and o.max() < np.pi**(2./3.)*0.5+1.e-9, f'{m},{o},{rot.as_quaternion()}'
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
+
+    @pytest.mark.parametrize('degrees',[True,False])
+    def test_Eulers(self,multidim_rotations,degrees):
+        m = multidim_rotations
+        o = Rotation.from_Euler_angles(m.as_Euler_angles(degrees),
+                                       degrees=degrees)
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
+
+    @pytest.mark.parametrize('degrees',[True,False])
+    @pytest.mark.parametrize('normalize',[True,False])
+    @pytest.mark.parametrize('P',[1,-1])
+    def test_axis_angle(self,multidim_rotations,degrees,normalize,P):
+        c = np.array([-P,-P,-P,1.])
+        c[:3] *= 0.9 if normalize else 1.0
+
+        m = multidim_rotations
+        o = Rotation.from_axis_angle(m.as_axis_angle(degrees)*c,
+                                     degrees=degrees,
+                                     normalize=normalize,
+                                     P=P)
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
+
+    def test_matrix(self,multidim_rotations):
+        m = multidim_rotations
+        o = Rotation.from_matrix(m.as_matrix())
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
+
+    def test_parallel(self,multidim_rotations):
+        m = multidim_rotations
+        a = np.broadcast_to(np.array([[1.0,0.0,0.0],
+                                      [0.0,1.0,0.0]]),m.shape+(2,3))
+        assert m.allclose(Rotation.from_parallel(a,m.broadcast_to(m.shape+(2,))@a))
+
+
+    @pytest.mark.parametrize('normalize',[True,False])
+    @pytest.mark.parametrize('P',[1,-1])
+    def test_Rodrigues(self,multidim_rotations,normalize,P):
+        c = np.array([-P,-P,-P,1.])
+        c[:3] *= 0.9 if normalize else 1.0
+        m = multidim_rotations
+        o = Rotation.from_Rodrigues_vector(m.as_Rodrigues_vector()*c,
+                                           normalize=normalize,
+                                           P=P)
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
+
+    def test_Rodrigues_compact(self,multidim_rotations):
+        m = multidim_rotations
+        c = m.as_Rodrigues_vector(compact=True)
+        r = m.as_Rodrigues_vector(compact=False)
+        assert np.allclose(r[...,:3]*r[...,3:], c, equal_nan=True)
+
+
+    @pytest.mark.parametrize('P',[1,-1])
+    def test_homochoric(self,multidim_rotations,P):
+        m = multidim_rotations
+        o = Rotation.from_homochoric(m.as_homochoric()*-P,
+                                     P=P)
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
+
+    @pytest.mark.parametrize('P',[1,-1])
+    def test_cubochoric(self,multidim_rotations,P):
+        m = multidim_rotations
+        o = Rotation.from_cubochoric(m.as_cubochoric()*-P,
+                                     P=P)
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
 
     @pytest.mark.parametrize('reciprocal',[True,False])
-    def test_basis(self,set_of_rotations,reciprocal):
+    def test_basis(self,multidim_rotations,reciprocal):
-        for rot in set_of_rotations:
+        m = multidim_rotations
-            om = rot.as_matrix() + 0.1*np.eye(3)
+        r = m.as_matrix()
-            rot = Rotation.from_basis(om,False,reciprocal=reciprocal)
+        r = np.linalg.inv(tensor.transpose(r)/np.pi) if reciprocal else r
-            assert np.isclose(np.linalg.det(rot.as_matrix()),1.0)
+        o = Rotation.from_basis(r,
+                                reciprocal=reciprocal)
+        f = Rotation(np.where(np.isclose(m.as_quaternion()[...,0],0.0,atol=atol)[...,np.newaxis],~o,o))
+        assert np.logical_or(m.isclose(o,atol=atol),
+                             m.isclose(f,atol=atol)
+                            ).all()
+
 
     @pytest.mark.parametrize('shape',[None,1,(4,4)])
     def test_random(self,shape):
         r = Rotation.from_random(shape)
-        if shape is None:
+        assert r.shape == () if shape is None else (1,) if shape == 1 else shape
-            assert r.shape == ()
-        elif shape == 1:
-            assert r.shape == (1,)
-        else:
-            assert r.shape == shape
 
     @pytest.mark.parametrize('shape',[None,5,(4,6)])
     def test_equal(self,shape):
@@ -947,13 +997,13 @@ class TestRotation:
         p = np.random.rand(n,3)
         o = Rotation._get_pyramid_order(p,direction)
         for i,o_i in enumerate(o):
-            assert np.all(o_i==Rotation._get_pyramid_order(p[i],direction))
+            assert (o_i==Rotation._get_pyramid_order(p[i],direction)).all()
 
     def test_pyramid_invariant(self):
         a = np.random.rand(n,3)
         f = Rotation._get_pyramid_order(a,'forward')
         b = Rotation._get_pyramid_order(a,'backward')
-        assert np.all(np.take_along_axis(np.take_along_axis(a,f,-1),b,-1) == a)
+        assert (np.take_along_axis(np.take_along_axis(a,f,-1),b,-1) == a).all()
 
 
     @pytest.mark.parametrize('data',[np.random.rand(5,3),