def test_monodromy_path(self):
        PF = RiemannSurfacePathFactory(self.X1, base_point=-2,
                                       base_sheets=[-1.j*sqrt(2),1.j*sqrt(2)])
        gamma_x = PF.complex_path_factory.monodromy_path(0)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        radius = PF.complex_path_factory.radius(0)
        self.assertAlmostEqual(gamma.get_x(0.0), -2)
        self.assertAlmostEqual(gamma.get_x(0.5), radius)
        self.assertAlmostEqual(gamma.get_x(1.0), -2)

        self.assertAlmostEqual(gamma.get_y(0.0)[0], -1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(0.0)[1], 1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(1.0)[0], 1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(1.0)[1], -1.j*sqrt(2))

        PF = RiemannSurfacePathFactory(self.X2, base_point=-2,
                                       base_sheets=[-sqrt(5),sqrt(5)])
        gamma_x = PF.complex_path_factory.monodromy_path(-I)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(0.0), -2)
        self.assertAlmostEqual(gamma.get_x(1.0), -2)

        self.assertAlmostEqual(gamma.get_y(0.0)[0], -sqrt(5))
        self.assertAlmostEqual(gamma.get_y(0.0)[1], sqrt(5))
        self.assertAlmostEqual(gamma.get_y(1.0)[0], sqrt(5))
        self.assertAlmostEqual(gamma.get_y(1.0)[1], -sqrt(5))
    def test_composite_line_smale(self):
        PF = RiemannSurfacePathFactory(self.X1, base_point=-3,
                                       base_sheets=[-1.j*sqrt(3),1.j*sqrt(3)])
        gamma_x = ComplexLine(-3,-2) + ComplexLine(-2,-1)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(0.0), -3)
        self.assertAlmostEqual(gamma.get_y(0.0)[0], -1.j*sqrt(3))
        self.assertAlmostEqual(gamma.get_y(0.0)[1], 1.j*sqrt(3))

        self.assertAlmostEqual(gamma.get_x(0.5), -2)
        self.assertAlmostEqual(gamma.get_y(0.5)[0], -1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(0.5)[1], 1.j*sqrt(2))

        self.assertAlmostEqual(gamma.get_x(1.0), -1)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], -1.j)
        self.assertAlmostEqual(gamma.get_y(1.0)[1], 1.j)

        # swap the base sheets
        PF = RiemannSurfacePathFactory(self.X1, base_point=-3,
                                       base_sheets=[1.j*sqrt(3),-1.j*sqrt(3)])
        gamma_x = ComplexLine(-3,-2) + ComplexLine(-2,-1)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(0.0), -3)
        self.assertAlmostEqual(gamma.get_y(0.0)[0], 1.j*sqrt(3))
        self.assertAlmostEqual(gamma.get_y(0.0)[1], -1.j*sqrt(3))

        self.assertAlmostEqual(gamma.get_x(0.5), -2)
        self.assertAlmostEqual(gamma.get_y(0.5)[0], 1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(0.5)[1], -1.j*sqrt(2))

        self.assertAlmostEqual(gamma.get_x(1.0), -1)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], 1.j)
        self.assertAlmostEqual(gamma.get_y(1.0)[1], -1.j)
    def test_primitive_line_smale(self):
        PF = RiemannSurfacePathFactory(self.X1, base_point=-1,
                                       base_sheets=[-1.j,1.j])
        gamma_x = ComplexLine(-1,-2)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(1.0), -2)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], -1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(1.0)[1], 1.j*sqrt(2))

        # swap the base sheets
        PF = RiemannSurfacePathFactory(self.X1, base_point=-1,
                                       base_sheets=[1.j,-1.j])
        gamma_x = ComplexLine(-1,-2)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(1.0), -2)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], 1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(1.0)[1], -1.j*sqrt(2))
    def test_primitive_arc_smale(self):
        PF = RiemannSurfacePathFactory(self.X1, base_point=-1,
                                       base_sheets=[-1.j,1.j])
        gamma_x = ComplexArc(1, 0, pi, pi)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(1.0), 1)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], 1)
        self.assertAlmostEqual(gamma.get_y(1.0)[1], -1)

        # swap the base sheets
        PF = RiemannSurfacePathFactory(self.X1, base_point=-1,
                                       base_sheets=[1.j,-1.j])
        gamma_x = ComplexArc(1, 0, pi, pi)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertAlmostEqual(gamma.get_x(1.0), 1)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], -1)
        self.assertAlmostEqual(gamma.get_y(1.0)[1], 1)
    def test_composite_line_mixed(self):
        PF = RiemannSurfacePathFactory(self.X1, base_point=-2,
                                       base_sheets=[-1.j*sqrt(2),1.j*sqrt(2)])
        gamma_x = ComplexLine(-2,-1) + ComplexLine(-1,0)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertEqual(len(gamma.segments), 2)
        self.assertTrue(
            isinstance(gamma.segments[0], RiemannSurfacePathSmale))
        self.assertTrue(
            isinstance(gamma.segments[1], RiemannSurfacePathPuiseux))

        self.assertAlmostEqual(gamma.get_x(0.0), -2)
        self.assertAlmostEqual(gamma.get_y(0.0)[0], -1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(0.0)[1], 1.j*sqrt(2))

        self.assertAlmostEqual(gamma.get_x(0.5), -1)
        self.assertAlmostEqual(gamma.get_y(0.5)[0], -1.j)
        self.assertAlmostEqual(gamma.get_y(0.5)[1], 1.j)

        self.assertAlmostEqual(gamma.get_x(1.0), 0)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], 0)
        self.assertAlmostEqual(gamma.get_y(1.0)[1], 0)

        # swap the base sheets
        PF = RiemannSurfacePathFactory(self.X1, base_point=-2,
                                       base_sheets=[1.j*sqrt(2),-1.j*sqrt(2)])
        gamma_x = ComplexLine(-2,-1) + ComplexLine(-1,0)
        gamma = PF.RiemannSurfacePath_from_complex_path(gamma_x)
        self.assertEqual(len(gamma.segments), 2)
        self.assertTrue(
            isinstance(gamma.segments[0], RiemannSurfacePathSmale))
        self.assertTrue(
            isinstance(gamma.segments[1], RiemannSurfacePathPuiseux))

        self.assertAlmostEqual(gamma.get_x(0.0), -2)
        self.assertAlmostEqual(gamma.get_y(0.0)[0], 1.j*sqrt(2))
        self.assertAlmostEqual(gamma.get_y(0.0)[1], -1.j*sqrt(2))

        self.assertAlmostEqual(gamma.get_x(0.5), -1)
        self.assertAlmostEqual(gamma.get_y(0.5)[0], 1.j)
        self.assertAlmostEqual(gamma.get_y(0.5)[1], -1.j)

        self.assertAlmostEqual(gamma.get_x(1.0), 0)
        self.assertAlmostEqual(gamma.get_y(1.0)[0], 0)
        self.assertAlmostEqual(gamma.get_y(1.0)[1], 0)