| import unittest |
| import random |
| from itertools import permutations, product |
| import sympy as s |
| from axioryn.core import * |
| from axioryn.mesh import compile_faces, integrate_scales |
|
|
| Q=s.Rational |
| I=s.eye(3) |
|
|
| class GainTests(unittest.TestCase): |
| def test_balanced_cycle(self): |
| e=[GainEdge(0,1,2),GainEdge(1,2,3),GainEdge(2,0,Q(1,6))] |
| r=positive_gain_kernel(3,e) |
| self.assertTrue(r.feasible) |
| self.assertEqual(r.basis,s.Matrix([1,2,6])) |
| out=project_gain_scales(r,[1,1,1],[1,1,1],[Q(1,10)]*3,[10]*3) |
| self.assertEqual(out['alpha'],s.Matrix([Q(9,41)])) |
| def test_unbalanced_cycle(self): |
| r=positive_gain_kernel(3,[GainEdge(0,1,2),GainEdge(1,2,3),GainEdge(2,0,Q(1,5))]) |
| self.assertFalse(r.feasible) |
| self.assertNotEqual(r.witness['closed_walk_gain'],1) |
| def test_components(self): |
| r=positive_gain_kernel(4,[GainEdge(0,1,2)]) |
| self.assertEqual(r.basis.shape,(4,3)) |
| self.assertTrue(all(x>0 for x in r.potentials)) |
| def test_selfloop(self): |
| self.assertFalse(positive_gain_kernel(1,[GainEdge(0,0,2)]).feasible) |
| def test_nonpositive_rejected(self): |
| with self.assertRaises(ValueError): positive_gain_kernel(2,[GainEdge(0,1,-1)]) |
| def test_float_rejected(self): |
| with self.assertRaises(TypeError): positive_gain_kernel(2,[GainEdge(0,1,0.5)]) |
| def test_face_gain(self): |
| self.assertEqual(face_gain([2,4],[1,2]),{'kind':'gain','gain':2}) |
| def test_zero_face(self): |
| self.assertEqual(face_gain([0,0],[0,0])['kind'],'released') |
| def test_one_zero(self): |
| self.assertEqual(face_gain([0,0],[1,0])['reason'],'one_zero_trace') |
| def test_noncollinear(self): |
| self.assertEqual(face_gain([1,0],[1,1])['reason'],'noncollinear_traces') |
| def test_opposite(self): |
| self.assertEqual(face_gain([-1,0],[1,0])['reason'],'opposite_traces') |
| def test_random_planted(self): |
| rng=random.Random(314159) |
| for _ in range(100): |
| n=rng.randint(3,15) |
| d=[Q(rng.randint(1,7),rng.randint(1,7)) for _ in range(n)] |
| e=[GainEdge(j-1,j,d[j]/d[j-1]) for j in range(1,n)] |
| for _ in range(n): |
| a,b=rng.sample(range(n),2); e.append(GainEdge(a,b,d[b]/d[a])) |
| r=positive_gain_kernel(n,e) |
| self.assertTrue(r.feasible) |
| self.assertEqual(r.basis,s.Matrix([x/d[0] for x in d])) |
|
|
| class InterfaceTests(unittest.TestCase): |
| def test_generic(self): |
| self.assertEqual(interface_data(I,I,[1,2,2])['active_normal_components'],3) |
| def test_rank_two_family(self): |
| n=s.Matrix([Q(3,5),Q(4,5),0]); a=n |
| b=s.Matrix([2*a[0],a[1]/2,0]); B=I+(b-a)*n.T |
| out=interface_data(I,B,n) |
| self.assertEqual(out['ratios'],{0:s.Integer(2),1:Q(1,2)}) |
| self.assertGreater(B.det(),0) |
| def test_rank_one_family(self): |
| B=s.diag(3,1,1) |
| self.assertEqual(interface_data(I,B,[1,0,0])['ratios'],{0:s.Integer(3)}) |
| def test_high_dimensional_lock(self): |
| self.assertEqual(interface_data(s.eye(5),s.eye(5),[1,2,3,0,0])['active_normal_components'],3) |
| def test_orientation_excludes_reflection(self): |
| n=s.Matrix([Q(1,3),Q(2,3),Q(2,3)]) |
| with self.assertRaises(ValueError): interface_data(I,I-2*n*n.T,n) |
| def test_symbolic_classification(self): |
| a1,a2,a3=s.symbols('a1 a2 a3',nonzero=True) |
| t=s.symbols('t',nonzero=True) |
| a=s.Matrix([a1,a2,a3]); b=s.Matrix([t*a1,a2/t,a3/t]) |
| self.assertEqual(s.factor(b[1]*b[2]-a2*a3),-a2*a3*(t-1)*(t+1)/t**2) |
| def test_quantitative_rational_trials(self): |
| rng=random.Random(1729) |
| n=s.Matrix([Q(1,3),Q(2,3),Q(2,3)]) |
| for _ in range(120): |
| A=s.diag(*[Q(rng.randint(1,4)) for j in range(3)]) |
| a=A*n |
| b=s.Matrix([a[j]*(1+Q(rng.randint(-3,3),1000)) for j in range(3)]) |
| B=A+(b-a)*n.T |
| out=quantitative_interface_bound(A,B,n) |
| self.assertTrue(out['verified']) |
| def test_sharp_zero(self): |
| out=quantitative_interface_bound(I,I,[Q(1,3),Q(2,3),Q(2,3)]) |
| self.assertEqual(out['upper_bound_squared'],0) |
| def test_explicit_shear_necessity(self): |
| n=s.Matrix([Q(1,3),Q(2,3),Q(2,3)]) |
| B=I+s.Matrix([Q(1,100),0,0])*n.T |
| self.assertNotEqual((B*B.T)[0,1],0) |
| self.assertTrue(quantitative_interface_bound(I,B,n)['verified']) |
|
|
| class GaugeTests(unittest.TestCase): |
| def test_fake_torsion(self): |
| B=s.Matrix([[2],[0]]) |
| c=primitive_real_gauge_quotient(B)['C'] |
| b=s.Matrix([Q(1,2),3]) |
| self.assertTrue(all(x.q==1 for x in c*b)) |
| self.assertEqual(b+B*s.Matrix([-Q(1,4)]),s.Matrix([0,3])) |
| def test_primitive(self): |
| B=s.Matrix([[2,4],[4,8],[6,12]]) |
| r=primitive_real_gauge_quotient(B) |
| self.assertEqual(r['C']*r['integer_right_inverse'],s.eye(2)) |
| def test_no_gauge(self): |
| r=primitive_real_gauge_quotient(s.zeros(1,0)) |
| self.assertEqual(r['C'],s.eye(1)) |
| self.assertNotEqual((r['C']*s.Matrix([Q(1,2)]))[0].q,1) |
| def test_rotation_self_loop(self): |
| rot=s.Matrix([[0,-1,0],[1,0,0],[0,0,1]]) |
| B=twisted_incidence(1,[(0,0,rot)]) |
| r=primitive_real_gauge_quotient(B) |
| self.assertEqual(r['C'].rows,1) |
| self.assertEqual(B.rank(),2) |
| def test_tree_has_no_period_obstruction(self): |
| B=twisted_incidence(3,[(0,1,I),(1,2,I)]) |
| self.assertEqual(primitive_real_gauge_quotient(B)['C'].rows,0) |
| def test_two_loop_no_fixed_vector(self): |
| q1=s.diag(1,-1,-1); q2=s.diag(-1,1,-1) |
| B=twisted_incidence(1,[(0,0,q1),(0,0,q2)]) |
| self.assertEqual(B.rank(),3) |
| self.assertEqual(primitive_real_gauge_quotient(B)['C'].rows,3) |
| def test_random_rank_identity(self): |
| rng=random.Random(41) |
| rots=[] |
| for p in permutations(range(3)): |
| for sg in product((-1,1),repeat=3): |
| m=s.zeros(3) |
| for i,j in enumerate(p):m[i,j]=sg[i] |
| if m.det()==1:rots.append(m) |
| for _ in range(40): |
| v=rng.randint(1,4); beta=rng.randint(1,3) |
| edges=[(i-1,i,rng.choice(rots)) for i in range(1,v)] |
| edges += [(rng.randrange(v),rng.randrange(v),rng.choice(rots)) for i in range(beta)] |
| B=twisted_incidence(v,edges) |
| f=3*v-B.rank(); r=3*len(edges)-B.rank() |
| self.assertEqual(r,3*beta-3+f) |
| self.assertLessEqual(r,3*beta) |
|
|
| class OptimizationTests(unittest.TestCase): |
| def test_inactive_bounds(self): |
| out=box_equality_qp(s.eye(2),[0,0],[[1,1]],[2],[0,0],[3,3]) |
| self.assertEqual(out['alpha'],s.Matrix([1,1])) |
| self.assertEqual(out['cost'],1) |
| def test_active_bounds(self): |
| out=box_equality_qp(s.eye(2),[Q(9,10),Q(1,10)],[[1,1]],[1],[Q(1,5)]*2,[2,2]) |
| self.assertEqual(out['alpha'],s.Matrix([Q(4,5),Q(1,5)])) |
| self.assertEqual(out['cost'],Q(1,100)) |
| def test_rank_deficient_equality(self): |
| out=box_equality_qp(s.eye(2),[0,0],[[1,1],[2,2]],[2,4],[0,0],[3,3]) |
| self.assertEqual(out['alpha'],s.Matrix([1,1])) |
| def test_infeasible(self): |
| self.assertIsNone(box_equality_qp([[1]],[0],[[1]],[3],[0],[2])) |
| def test_coupled_integer_cannot_edit_offsets_freely(self): |
| out=bounded_integer_projection([[1]],[Q(49,100)],[[1],[2]],[0,0],[Q(2,5)],[Q(7,5)]) |
| self.assertEqual(out['alpha'],s.Matrix([1])) |
| self.assertEqual(out['integer_target'],s.Matrix([1,2])) |
| self.assertEqual(out['cost'],Q(2601,20000)) |
| def test_bounded_integer_infeasible(self): |
| self.assertIsNone(bounded_integer_projection([[1]],[Q(1,2)],[[1]],[0],[Q(2,5)],[Q(3,5)])) |
| def test_cap(self): |
| with self.assertRaises(ValueError): |
| bounded_integer_projection([[1]],[0],[[1]],[0],[0],[100],max_targets=2) |
|
|
| class MeshTests(unittest.TestCase): |
| def setUp(self): |
| self.V=[[0,0,0],[0,1,0],[0,0,1],[-1,0,0],[1,0,0]] |
| self.T=[[0,1,2,3],[0,2,1,4]] |
| def test_face_aligned_flexibility(self): |
| out=compile_faces(self.V,self.T,[I,I]) |
| self.assertTrue(out['feasible']) |
| self.assertEqual(out['basis'].cols,4) |
| def test_actual_pl_reconstruction(self): |
| out=integrate_scales(self.V,self.T,[I,I],[1,2,3,2,2,3]) |
| self.assertTrue(out['integrable']) |
| self.assertEqual(out['determinants'],[6,12]) |
| self.assertEqual(out['global_injectivity'],'NOT_CERTIFIED') |
| def test_generic_face_constant_directions(self): |
| v=[[0,0,0],[1,-1,0],[1,0,-1],[1,1,1],[-1,-1,-1]] |
| out=compile_faces(v,self.T,[I,I]) |
| self.assertTrue(out['feasible']) |
| self.assertEqual(out['basis'].cols,3) |
| def test_generic_rotated_rejected(self): |
| v=[[0,0,0],[1,-1,0],[1,0,-1],[1,1,1],[-1,-1,-1]] |
| r=s.Matrix([[Q(3,5),-Q(4,5),0],[Q(4,5),Q(3,5),0],[0,0,1]]) |
| self.assertFalse(compile_faces(v,self.T,[I,r])['feasible']) |
| def test_degenerate_rejected(self): |
| with self.assertRaises(ValueError):compile_faces([[0,0,0]]*4,[[0,1,2,3]],[I]) |
| def test_trace_failure_rejected(self): |
| self.assertFalse(integrate_scales(self.V,self.T,[I,I],[1,2,3,2,4,3])['integrable']) |
|
|
|
|
| class InjectivityCounterexampleTests(unittest.TestCase): |
| @staticmethod |
| def prism_data(): |
| ring=[(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)] |
| target=[(1,0),(0,1),(-1,0),(0,-1)]*2 |
| v2=[(0,0)]+ring; u2=[(0,0)]+target |
| V=s.Matrix([[x,y,z] for z in (0,1) for x,y in v2]) |
| U=s.Matrix([[x,y,z] for z in (0,1) for x,y in u2]) |
| tets=[] |
| for j in range(8): |
| a,b,c=sorted([0,1+j,1+(j+1)%8]) |
| tets += [[a,b,c,c+9],[a,b,b+9,c+9],[a,a+9,b+9,c+9]] |
| return V,U,tets |
| def test_all_twentyfour_tets_positive(self): |
| V,U,T=self.prism_data() |
| for ids in T: |
| X=s.Matrix.hstack(*[(V[i,:]-V[ids[0],:]).T for i in ids[1:]]) |
| Y=s.Matrix.hstack(*[(U[i,:]-U[ids[0],:]).T for i in ids[1:]]) |
| self.assertEqual((Y*X.inv()).det(),1) |
| def test_double_cover_collision(self): |
| V,U,T=self.prism_data() |
| |
| p=(V[0,:]+V[1,:]+V[2,:])/3+s.Matrix([[0,0,s.Rational(1,2)]]) |
| q=(V[0,:]+V[5,:]+V[6,:])/3+s.Matrix([[0,0,s.Rational(1,2)]]) |
| imagep=(U[0,:]+U[1,:]+U[2,:])/3 |
| imageq=(U[0,:]+U[5,:]+U[6,:])/3 |
| self.assertNotEqual(p,q) |
| self.assertEqual(imagep,imageq) |
|
|
| if __name__=='__main__':unittest.main() |
|
|
