def with_lagrange(): ## This function tests the fact that non real solutions are discarded. echo_function("with_lagrange") x = var('x') mx = -6 Mx = 2.7 intersections = [ Point(-5.5, 1.5), Point(-3.5, 1), Point(-1, 1), Point(1.5, -1) ] pts1 = intersections[:] pts1.extend([Point(-4.5, -1), Point(-2, 3), Point(1, -1), Point(2.5, 0)]) lag1 = LagrangePolynomial(pts1) pts2 = intersections[:] pts2.extend([Point(-4.5, 2.5), Point(-2, 0), Point(0, 1.5), Point(2, -2)]) lag2 = LagrangePolynomial(pts2) ans = [] ans.append(Point(-6.381638163816381, -1.821966693100714)) ans.append(Point(-11 / 2, 3 / 2)) ans.append(Point(-7 / 2, 1)) ans.append(Point(-1, 1)) ans.append(Point(3 / 2, -1)) pts = Intersection(lag1, lag2) for PP in zip(ans, pts): assert_equal(PP[0], PP[1])
def orthogonal_decompostion(): echo_function("orthogonal_decomposition") v = Vector(2, 3) perp, parall = v.decomposition(Segment(Point(0, 0), Point(0, 1))) echo_single_test("In the Y direction") ans_parall = AffineVector(Point(0, 0), Point(0, 3)) ans_perp = AffineVector(Point(0, 0), Point(2, 0)) assert_true(parall + perp == v) assert_equal(parall, ans_parall) assert_equal(perp, ans_perp) P = Point(0, 2) seg = Segment(P, P.get_polar_point(2, -130)) Q = seg.get_point_proportion(0.5) v = AffineVector(Q, Point(Q.x - 1, Q.y)) perp, paral = v.decomposition(seg) echo_single_test("130 degree : sum") assert_equal(perp + paral, v) echo_single_test("130 degree : orthogonal") assert_true(perp.segment.is_almost_orthogonal(seg, epsilon=0.0001)) ip = perp.inner_product(paral) echo_single_test("130 degree : inner product 1") assert_equal(perp.inner_product(paral), 0) echo_single_test("130 degree : inner product 2") assert_equal(paral.inner_product(perp), 0)
def testAngleMeasure(): echo_function("testAngleMeasure") comparison() alpha=AngleMeasure(value_degree=360) assert_equal(alpha.__repr__(), "AngleMeasure, degree=360.000000000000,radian=2*pi") alpha=AngleMeasure(value_degree=30) assert_equal(cos(alpha.radian),1/2*sqrt(3)) alpha=AngleMeasure(value_degree=180) beta=AngleMeasure(alpha) assert_equal(beta.degree,180) alpha=AngleMeasure(value_degree=-(3.47548077273962e-14)/pi + 360) assert_equal(alpha.degree,360) assert_equal(alpha.radian,2*pi) alpha=AngleMeasure(value_degree=-30) assert_equal(alpha.positive().degree,330) alpha=AngleMeasure(value_degree=45) beta=AngleMeasure(value_radian=pi/3) assert_equal(alpha.degree,45) assert_equal(alpha.radian,1/4*pi) assert_equal(beta.degree,60) assert_equal(beta.radian,1/3*pi) a_sum_b = alpha+beta assert_equal(a_sum_b.degree,105) assert_equal(a_sum_b.radian,7/12*pi)
def lines_and_functions(): """ Test the intersection function """ echo_function("lines_and_functions") x = var('x') fun = phyFunction(x**2 - 5 * x + 6) droite = phyFunction(2) pts = Intersection(fun, droite) echo_single_test("Function against horizontal line") assert_equal(pts[0], Point(1, 2)) assert_equal(pts[1], Point(4, 2)) echo_single_test("Two functions (sine and cosine)") f = phyFunction(sin(x)) g = phyFunction(cos(x)) pts = Intersection(f, g, -2 * pi, 2 * pi, numerical=True) # due to the default epsilon in `assert_almost_equal`, # in fact we do not test these points with the whole given precision. ans = [] ans.append(Point(-5.497787143782138, 0.707106781186548)) ans.append(Point(-2.3561944901923466, -0.707106781186546)) ans.append(Point(0.7853981633974484, 0.707106781186548)) ans.append(Point(3.926990816987241, -0.707106781186547)) for t in zip(pts, ans): assert_almost_equal(t[0], t[1])
def test_OMZO(): echo_function("test_OMZO") f = "Fig_OMZOoowEtRUuMi.pstricks" g = "Fig_OMZOoowEtRUuMi.pstricks.recall" comparison(f, g, 0.001)
def test_zero(): echo_function("test_zero") text = "\draw [e=d] plot [s,t=1] coordinates {(1.00,0)(1.05,0.0320))};" fd = TestRecall.TikzDecomposition(text) fdp = [str(p) for p in fd.points_list] ans_points = ["(1.0,0.0)", "(1.05,0.032)"] assert_equal(fdp, ans_points)
def test_almost_equal(): echo_function("test_almost_equal") s = Segment(Point(1, 1), Point(2, 2)) v = s.get_normal_vector() assert_equal(v.I, Point(1.5, 1.5)) assert_almost_equal(v.length, 1, epsilon=0.001) assert_almost_equal(v.F, Point(1 / 2 * sqrt(2) + 1.5, -1 / 2 * sqrt(2) + 1.5), epsilon=0.001)
def test_text_parenthesis(): echo_function("test_text_parenthesis") text = "\subfigure[more points (5000)]{%" fd = TestRecall.TikzDecomposition(text) assert_true(fd.points_list == []) assert_true(len(fd.texts_list) == 2) assert_equal(fd.texts_list[0], "\subfigure[more points ") assert_equal(fd.texts_list[1], "5000)]{%")
def testFGetMinMaxData(): echo_function("testFGetMinMaxData") x, y = var('x,y') F = ImplicitCurve(x**2+y**2 == sqrt(2), (x, -5, 5), (y, -4, 4), plot_points=300) F.plot_points = 10 d = F.get_minmax_data() ans_d = {'xmax': 1.1885897706607917, 'xmin': -1.1885897706608, 'ymax': 1.188452472892108, 'ymin': -1.1884524728921004} assert_true(d == ans_d, failure_message="get_min_max data badly computed.")
def test_vertical_horizontal(): echo_function("test_vertical_horizontal") A = Point(1.50000000000000 * cos(0.111111111111111 * pi), -1.50000000000000 * sin(0.111111111111111 * pi)) B = Point(3.00000000000000 * cos(0.111111111111111 * pi), -3.00000000000000 * sin(0.111111111111111 * pi)) seg = Segment(A, B) assert_equal(seg.is_vertical, False) assert_equal(seg.is_horizontal, False)
def comparison(): echo_function("comparison") alpha=AngleMeasure(value_degree=30) beta=AngleMeasure(value_radian=pi/2) assert_true(alpha<beta) assert_true(alpha<=alpha) assert_true(alpha==alpha) assert_false(alpha==beta) assert_true(alpha>=alpha)
def test_reverse(): echo_function("test_reverse") x = var('x') curve = ParametricCurve(cos(x), sin(x)).graph(0, 2 * pi).reverse() f1 = cos(-x) f2 = sin(-x) assert_true(curve.f1.sage == f1) assert_true(curve.f2.sage == f2)
def test_add_bounding_box(): echo_function("test_add_bounding_box") with SilentOutput(): pspict, fig = SinglePicture("YDTGooZGkkei") A = Point(4.00000000000000 * cos(0.111111111111111 * pi), 0) B = Point(0, 0) pspict.DrawGraphs(A, B) fig.conclude()
def test_math(): echo_function("test_math") text = "#\setlength{\lengthOf}{\total{$f(x)$}}% (1,1)" fd = TestRecall.TikzDecomposition(text) fdp = [str(p) for p in fd.points_list] ans_texts = ['#\\setlength{\\lengthOf}{\total{$f', 'x)$}}% ', ')'] ans_points = ["(1.0,1.0)"] assert_equal(fdp, ans_points) assert_equal(fd.texts_list, ans_texts)
def test_equalities(): echo_function("test_equalities") # I do not remember what this test was about. # I seems that with some old version of Sage, the computation # of v1+v2 was raising an OverflowError. a = 3.00000000000000 * cos(0.111111111111111 * pi) b = 3.00000000000000 * cos(0.111111111111111 * pi) P = Point(a, 0) A = Point(0, 0) B = Point(1, 1) v1 = AffineVector(P, A) v2 = AffineVector(P, B) d = v1 + v2 # Just compute the sum
def test_is_negative(): echo_function("test_is_negative") echo_single_test("some values") a = -sin(0.5 * pi) assert_true(numerical_is_negative(a)) a = -pi assert_true(numerical_is_negative(a)) a = pi assert_false(numerical_is_negative(a)) echo_single_test("zero is not negative") assert_false(numerical_is_negative(0))
def point_translation(): echo_function("translation") v = Vector(2, 1) P = Point(-1, -1) assert_equal(P.translate(v), Point(1, 0)) w = AffineVector(Point(1, 1), Point(2, 3)) assert_equal(P.translate(w), Point(0, 1)) assert_equal(P.translate(10, -9), Point(9, -10)) x, y = var('x,y') P = Point(x, y) assert_equal(P.translate(Vector(-P)), Point(0, 0))
def test_right_angle(): echo_function("test_right_angle") with SilentOutput(): pspict, fig = SinglePicture("HYVFooTHaDDQ") A = Point(2.96406976477346 * cos(-1 / 9 * pi + 1.09432432510594), 2.96406976477346 * sin(-1 / 9 * pi + 1.09432432510594)) B = Point(1.50000000000000 * cos(0.111111111111111 * pi), -1.50000000000000 * sin(0.111111111111111 * pi)) C = Point(3.00000000000000 * cos(0.111111111111111 * pi), -3.00000000000000 * sin(0.111111111111111 * pi)) rh = RightAngleAOB(A, B, C) pspict.DrawGraphs(rh)
def with_box(): # The "demonstration picture" BOVAooIlzgFQpG serves to test # how it works visually. echo_function("with_box") from phystricks.src.Utilities import point_to_box_intersection echo_single_test("one box ...") P = Point(1, 1) box = BoundingBox(xmin=2, ymin=3, xmax=6, ymax=4) ans = [Point(17 / 5, 3), Point(23 / 5, 4)] for t in zip(ans, point_to_box_intersection(P, box)): assert_equal(t[0], t[1]) echo_single_test("an other box ...") P = Point(1, 1) box = BoundingBox(xmin=1, ymin=3, xmax=4, ymax=4) ans = [Point(11 / 5, 3), Point(14 / 5, 4)] for t in zip(ans, point_to_box_intersection(P, box)): assert_equal(t[0], t[1]) echo_single_test("an other box ...") P = Point(0, 0) box = BoundingBox(xmin=cos(pi + 0.109334472936971) - 0.5, xmax=cos(pi + 0.109334472936971) + 0.5, ymin=sin(pi + 0.109334472936971) - 0.5, ymax=sin(pi + 0.109334472936971) + 0.5) ans = [Point(11 / 5, 3), Point(14 / 5, 4)] ans=[Point(-22625191/45797299,-116397308741499/2146337772042166),\ Point(-11397639/7628794,-58636168225371/357531318982996)] for t in zip(ans, point_to_box_intersection(P, box)): assert_equal(t[0], t[1]) echo_single_test("point->center parallel to a edge") P = Point(0, 0) box = BoundingBox(xmin=-2.0719775, xmax=-0.8437425000000001, ymin=-0.1148125, ymax=0.1148125) ans = [Point(-337497 / 400000, 0), Point(-828791 / 400000, 0)] for t in zip(ans, point_to_box_intersection(P, box)): assert_equal(t[0], t[1]) echo_single_test("an other box (corner) ...") P = Point(0, 1) box = BoundingBox(xmin=-1, ymin=-3, xmax=-0.5, ymax=-1) ans = [Point(-0.5, -1), Point(-1, -3)] for t in zip(ans, point_to_box_intersection(P, box)): assert_equal(t[0], t[1])
def test_is_negative(): from phystricks.src.Numerical import numerical_is_negative echo_function("test_is_negative") echo_single_test("some values") a = -sin(0.5 * pi) assert_true(numerical_is_negative(a)) a = -pi assert_true(numerical_is_negative(a)) a = pi assert_false(numerical_is_negative(a)) echo_single_test("zero is not negative") assert_false(numerical_is_negative(0))
def test_decorator(): echo_function("test_decorator") v = AffineVector(Point(1, 1), Point(2, 2)) echo_single_test("initial value : None") assert_true(v.parameters.color == None) assert_true(v.parameters.style == None) v.parameters.color = "foo" v.parameters.style = "bar" echo_single_test("after fix_origin") w = v.fix_origin(Point(3, 4)) assert_true(w.parameters.color == "foo") assert_true(w.parameters.style == "bar")
def test_vector_equality(): echo_function("test_vector_equality") A = Point(1, 1) B = Point(2, -3) vv = AffineVector(A, B) ww = AffineVector(A, B) echo_single_test("Two trivial equalities") assert_equal(vv, vv) assert_equal(ww, ww) echo_single_test("One less trivial equalities") assert_equal(vv, ww)
def test_number_to_string(): echo_function("test_number_to_string") a = 7.73542889062775*cos(11/9*pi + 1.30951587282752) - \ 7.55775391156456*cos(5/18*pi) + 2.5*cos(2/9*pi) assert_equal(number_to_string(a, digits=7), "0.329851") assert_equal(number_to_string(0, digits=15), "0.00000000000000") assert_equal(number_to_string(120, digits=3), "120") assert_equal(number_to_string(120, digits=5), "120.00") assert_equal(number_to_string(120.67, digits=3), "120") assert_equal(number_to_string(120.67, digits=4), "120.6") assert_equal(number_to_string(120.67, digits=14), "120.67000000000") assert_equal(number_to_string(-1, digits=3), "-1.00") assert_equal(number_to_string(-12, digits=2), "-12") assert_equal(number_to_string(-0.1234, digits=6), "-0.12340") assert_equal(number_to_string(-0.12, digits=3), "-0.12")
def test_visual_length(): echo_function("test_visual_length") with SilentOutput(): pspict, fig = SinglePicture("ZZTHooTeGyMT") v = AffineVector(Point(0, 0), Point(0, sin(0.5 * pi))) w = visual_length(v, 0.1, pspict=pspict) ans = AffineVector(Point(0, 0), Point(0, 0.1)) echo_single_test("positive") assert_equal(w, ans) echo_single_test("negative") v = AffineVector(Point(0, 0), Point(0, -sin(0.5 * pi))) w = visual_length(v, 0.1, pspict=pspict) ans = AffineVector(Point(0, 0), Point(0, -0.1)) assert_equal(w, ans)
def test_equalities(): echo_function("test_equalities") a = 3.00000000000000 * cos(0.111111111111111 * pi) b = 3.00000000000000 * cos(0.111111111111111 * pi) P = Point(a, 0) A = Point(0, 0) B = Point(1, 1) v1 = AffineVector(P, A) v2 = AffineVector(P, B) on = True try: d = v1 + v2 except OverflowError: on = False assert_false(on)
def test_non_equalities(): echo_function("test_non_equalities") A = Point(0, 0) B = Point(4.00000000000000 * cos(0.111111111111111 * pi), 0) echo_single_test("difficult not 'almost equal'") assert_false(A.is_almost_equal(B)) echo_single_test("difficult not 'really equal'") assert_false(A == B) v = AffineVector(A, B) u = AffineVector(B, A) w = AffineVector(A, -B) echo_single_test("difficult not 'almost equal' for affine vector") assert_false(v.is_almost_equal(w)) echo_single_test("difficult 'almost equal' for affine vector") assert_true(w.is_almost_equal(-v))
def test_second_derivative_vector(): echo_function("test_second_derivative_vector") F = ParametricCurve(x, x**3) echo_single_test("normalize=true") v = F.get_second_derivative_vector(0, normalize=True) ans = AffineVector(Point(0, 0), Point(0, 0)) assert_equal(v, ans) echo_single_test("normalize=false") v = F.get_second_derivative_vector(0, normalize=False) ans = AffineVector(Point(0, 0), Point(0, 0)) assert_equal(v, ans) echo_single_test("On an other point") v = F.get_second_derivative_vector(1) ans = AffineVector(Point(1, 1), Point(1, 2)) assert_equal(v, ans)
def testEnsureUnicode(): echo_function("testEnsureUnicode") from phystricks.src.NoMathUtilities import ensure_unicode from phystricks.src.NoMathUtilities import ensure_str u1 = u"éà" s1 = "éà" uni_u1 = ensure_unicode(u1) str_u1 = ensure_str(u1) assert_equal(uni_u1, u1) assert_equal(str_u1, s1) s2 = "éàù" double_s2 = ensure_str(ensure_unicode(s2)) assert_equal(double_s2, s2) u2 = u"éàù" double_u2 = ensure_unicode(ensure_str(u2)) assert_equal(double_u2, u2)
def segment_translation(): echo_function("segment_translation") segment = Segment(Point(-1, 3), Point(pi, 0)) # One tuple and 3 ways to describe the same vector. t = (1, 7) v1 = AffineVector(Point(0, 0), Point(1, 7)) v2 = AffineVector(Point(5, 6), Point(6, 13)) v3 = Vector(1, 7) s1 = segment.translate(1, 7) s2 = segment.translate(t) s3 = segment.translate(v1) s4 = segment.translate(v2) s5 = segment.translate(v3) ans = Segment(Point(0, 10), Point(pi + 1, 7)) assert_equal(s1, ans) assert_equal(s2, ans) assert_equal(s3, ans) assert_equal(s4, ans) assert_equal(s5, ans)
def test_split(): echo_function("test_split") text = "aaaZbbZcc" echo_single_test("only internal") it = TestRecall.split_for_positions(text, [3, 6]) lit = list(it) ans = ['aaa', 'bb', 'cc'] assert_equal(lit, ans) echo_single_test("left border") text = "stuZbbZcc" it = TestRecall.split_for_positions(text, [0, 3, 6]) lit = list(it) ans = ['', 'stu', 'bb', 'cc'] assert_equal(lit, ans) echo_single_test("right border") text = "stuZbbZccZ" it = TestRecall.split_for_positions(text, [0, 3, 6, 9]) lit = list(it) ans = ['', 'stu', 'bb', 'cc', ''] assert_equal(lit, ans)