Coverage for local/lib/python2.7/site-packages/sage/geometry/riemannian_manifolds/parametrized

Parametrized surface ('Klein bottle') with equation (-(sin(1/2*u)*sin(2*v) - cos(1/2*u)*sin(v) - 1)*cos(u), -(sin(1/2*u)*sin(2*v) - cos(1/2*u)*sin(v) - 1)*sin(u), cos(1/2*u)*sin(2*v) + sin(1/2*u)*sin(v))

Latex representation of the surfaces::

sage: u, v = var('u, v', domain='real')

sage: sphere = ParametrizedSurface3D((cos(u)*cos(v), sin(u)*cos(v), sin(v)), (u, v), 'sphere')

sage: print(latex(sphere))

\left(\cos\left(u\right) \cos\left(v\right), \cos\left(v\right) \sin\left(u\right), \sin\left(v\right)\right)

sage: print(sphere._latex_())

\left(\cos\left(u\right) \cos\left(v\right), \cos\left(v\right) \sin\left(u\right), \sin\left(v\right)\right)

sage: print(sphere)

Parametrized surface ('sphere') with equation (cos(u)*cos(v), cos(v)*sin(u), sin(v))

To plot a parametric surface, use the :meth:`plot` member function::

sage: enneper = surfaces.Enneper(); enneper

Parametrized surface ('Enneper's surface') with equation (-1/9*(u^2 - 3*v^2 - 3)*u, -1/9*(3*u^2 - v^2 + 3)*v, 1/3*u^2 - 1/3*v^2)

sage: enneper.plot(aspect_ratio='automatic')

Graphics3d Object

We construct an ellipsoid whose axes are given by symbolic variables `a`,

`b` and `c`, and find the natural frame of tangent vectors,

expressed in intrinsic coordinates. Note that the result is a

dictionary of vector fields::

sage: a, b, c = var('a, b, c', domain='real')

sage: u1, u2 = var('u1, u2', domain='real')

sage: ellipsoid_eq = (a*cos(u1)*cos(u2), b*sin(u1)*cos(u2), c*sin(u2))

sage: ellipsoid = ParametrizedSurface3D(ellipsoid_eq, (u1, u2), 'Symbolic ellipsoid'); ellipsoid

Parametrized surface ('Symbolic ellipsoid') with equation (a*cos(u1)*cos(u2), b*cos(u2)*sin(u1), c*sin(u2))

sage: ellipsoid.natural_frame()

{1: (-a*cos(u2)*sin(u1), b*cos(u1)*cos(u2), 0), 2: (-a*cos(u1)*sin(u2), -b*sin(u1)*sin(u2), c*cos(u2))}

We find the normal vector field to the surface. The normal vector

field is the vector product of the vectors of the natural frame,

and is given by::

sage: ellipsoid.normal_vector()

(b*c*cos(u1)*cos(u2)^2, a*c*cos(u2)^2*sin(u1), a*b*cos(u2)*sin(u2))

By default, the normal vector field is not normalized. To obtain

the unit normal vector field of the elliptic paraboloid, we put::

sage: u, v = var('u,v', domain='real')

sage: eparaboloid = ParametrizedSurface3D([u,v,u^2+v^2],[u,v],'elliptic paraboloid')

sage: eparaboloid.normal_vector(normalized=True)

(-2*u/sqrt(4*u^2 + 4*v^2 + 1), -2*v/sqrt(4*u^2 + 4*v^2 + 1), 1/sqrt(4*u^2 + 4*v^2 + 1))

Now let us compute the coefficients of the first fundamental form of the torus::

sage: u, v = var('u, v', domain='real')

sage: a, b = var('a, b', domain='real')

sage: torus = ParametrizedSurface3D(((a + b*cos(u))*cos(v),(a + b*cos(u))*sin(v), b*sin(u)),[u,v],'torus')

sage: torus.first_fundamental_form_coefficients()

{(1, 1): b^2, (1, 2): 0, (2, 1): 0, (2, 2): b^2*cos(u)^2 + 2*a*b*cos(u) + a^2}

The first fundamental form can be used to compute the length of a

curve on the surface. For example, let us find the length of the

curve $u^1 = t$, $u^2 = t$, $t \in [0,2\pi]$, on the ellipsoid

with axes $a=1$, $b=1.5$ and $c=1$. So we take the curve::

sage: t = var('t', domain='real')

sage: u1 = t

sage: u2 = t

Then find the tangent vector::

sage: du1 = diff(u1,t)

sage: du2 = diff(u2,t)

sage: du = vector([du1, du2]); du

(1, 1)

Once we specify numerical values for the axes of the ellipsoid, we can

determine the numerical value of the length integral::

sage: L = sqrt(ellipsoid.first_fundamental_form(du, du).substitute(u1=u1,u2=u2))

sage: numerical_integral(L.substitute(a=2, b=1.5, c=1),0,1)[0] # rel tol 1e-11

2.00127905972

We find the area of the sphere of radius $R$::

sage: R = var('R', domain='real');

sage: u, v = var('u,v', domain='real');

sage: assume(R>0)

sage: assume(cos(v)>0)

sage: sphere = ParametrizedSurface3D([R*cos(u)*cos(v),R*sin(u)*cos(v),R*sin(v)],[u,v],'sphere')

sage: integral(integral(sphere.area_form(),u,0,2*pi),v,-pi/2,pi/2)

4*pi*R^2

We can find an orthonormal frame field $\{e_1, e_2\}$ of a surface

and calculate its structure functions. Let us first determine the

orthonormal frame field for the elliptic paraboloid::

sage: u, v = var('u,v', domain='real')

sage: eparaboloid = ParametrizedSurface3D([u,v,u^2+v^2],[u,v],'elliptic paraboloid')

sage: eparaboloid.orthonormal_frame()

{1: (1/sqrt(4*u^2 + 1), 0, 2*u/sqrt(4*u^2 + 1)), 2: (-4*u*v/(sqrt(4*u^2 + 4*v^2 + 1)*sqrt(4*u^2 + 1)), sqrt(4*u^2 + 1)/sqrt(4*u^2 + 4*v^2 + 1), 2*v/(sqrt(4*u^2 + 4*v^2 + 1)*sqrt(4*u^2 + 1)))}

We can express the orthogonal frame field both in exterior

coordinates (i.e. expressed as vector field fields in the ambient

space $\RR^3$, the default) or in intrinsic coordinates

(with respect to the natural frame). Here we use intrinsic

coordinates::

sage: eparaboloid.orthonormal_frame(coordinates='int')

{1: (1/sqrt(4*u^2 + 1), 0), 2: (-4*u*v/(sqrt(4*u^2 + 4*v^2 + 1)*sqrt(4*u^2 + 1)), sqrt(4*u^2 + 1)/sqrt(4*u^2 + 4*v^2 + 1))}

Using the orthonormal frame in interior coordinates, we can calculate

the structure functions $c^k_{ij}$ of the surface, defined by

$[e_i,e_j] = c^k_{ij} e_k$, where $[e_i, e_j]$ represents the Lie

bracket of two frame vector fields $e_i, e_j$. For the

elliptic paraboloid, we get::

sage: EE = eparaboloid.orthonormal_frame(coordinates='int')

sage: E1 = EE[1]; E2 = EE[2]

sage: CC = eparaboloid.frame_structure_functions(E1,E2)

sage: CC[1,2,1].simplify_full()

4*sqrt(4*u^2 + 4*v^2 + 1)*v/((16*u^4 + 4*(4*u^2 + 1)*v^2 + 8*u^2 + 1)*sqrt(4*u^2 + 1))

We compute the Gaussian and mean curvatures of the sphere::

sage: sphere = surfaces.Sphere(); sphere

Parametrized surface ('Sphere') with equation (cos(u)*cos(v), cos(v)*sin(u), sin(v))

sage: K = sphere.gauss_curvature(); K # Not tested -- see trac 12737

sage: H = sphere.mean_curvature(); H # Not tested -- see trac 12737

-1

We can easily generate a color plot of the Gaussian curvature of a surface.

Here we deal with the ellipsoid::

sage: u1, u2 = var('u1,u2', domain='real');

sage: u = [u1,u2]

sage: ellipsoid_equation(u1,u2) = [2*cos(u1)*cos(u2),1.5*cos(u1)*sin(u2),sin(u1)]

sage: ellipsoid = ParametrizedSurface3D(ellipsoid_equation(u1,u2), [u1, u2],'ellipsoid')

sage: # set intervals for variables and the number of division points

sage: u1min, u1max = -1.5, 1.5

sage: u2min, u2max = 0, 6.28

sage: u1num, u2num = 10, 20

sage: # make the arguments array

sage: from numpy import linspace

sage: u1_array = linspace(u1min, u1max, u1num)

sage: u2_array = linspace(u2min, u2max, u2num)

sage: u_array = [ (uu1,uu2) for uu1 in u1_array for uu2 in u2_array]

sage: # Find the gaussian curvature

sage: K(u1,u2) = ellipsoid.gauss_curvature()

sage: # Make array of K values

sage: K_array = [K(uu[0],uu[1]) for uu in u_array]

sage: # Find minimum and max of the gauss curvature

sage: K_max = max(K_array)

sage: K_min = min(K_array)

sage: # Make the array of color coefficients

sage: cc_array = [ (ccc - K_min)/(K_max - K_min) for ccc in K_array ]

sage: points_array = [ellipsoid_equation(u_array[counter][0],u_array[counter][1]) for counter in range(0,len(u_array)) ]

sage: curvature_ellipsoid_plot = sum( point([xx for xx in points_array[counter]],color=hue(cc_array[counter]/2)) for counter in range(0,len(u_array)) )

sage: curvature_ellipsoid_plot.show(aspect_ratio=1)

We can find the principal curvatures and principal directions of the

elliptic paraboloid::

sage: u, v = var('u, v', domain='real')

sage: eparaboloid = ParametrizedSurface3D([u, v, u^2+v^2], [u, v], 'elliptic paraboloid')

sage: pd = eparaboloid.principal_directions(); pd

[(2*sqrt(4*u^2 + 4*v^2 + 1)/(16*u^4 + 16*v^4 + 8*(4*u^2 + 1)*v^2 + 8*u^2 + 1), [(1, v/u)], 1), (2/sqrt(4*u^2 + 4*v^2 + 1), [(1, -u/v)], 1)]

We extract the principal curvatures::

sage: k1 = pd[0][0].simplify_full()

sage: k1

2*sqrt(4*u^2 + 4*v^2 + 1)/(16*u^4 + 16*v^4 + 8*(4*u^2 + 1)*v^2 + 8*u^2 + 1)

sage: k2 = pd[1][0].simplify_full()

sage: k2

2/sqrt(4*u^2 + 4*v^2 + 1)

and check them by comparison with the Gaussian and mean curvature

expressed in terms of the principal curvatures::

sage: K = eparaboloid.gauss_curvature().simplify_full()

sage: K

4/(16*u^4 + 16*v^4 + 8*(4*u^2 + 1)*v^2 + 8*u^2 + 1)

sage: H = eparaboloid.mean_curvature().simplify_full()

sage: H

2*(2*u^2 + 2*v^2 + 1)/(4*u^2 + 4*v^2 + 1)^(3/2)

sage: (K - k1*k2).simplify_full()

sage: (2*H - k1 - k2).simplify_full()

We can find the intrinsic (local coordinates) of the principal directions::

sage: pd[0][1]

[(1, v/u)]

sage: pd[1][1]

[(1, -u/v)]

The ParametrizedSurface3D class also contains functionality to

compute the coefficients of the second fundamental form, the shape

operator, the rotation on the surface at a given angle, the

connection coefficients. One can also calculate numerically the

geodesics and the parallel translation along a curve.

Here we compute a number of geodesics on the sphere emanating

from the point ``(1, 0, 0)``, in various directions. The geodesics

intersect again in the antipodal point ``(-1, 0, 0)``, indicating

that these points are conjugate::

sage: S = surfaces.Sphere()

sage: g1 = [c[-1] for c in S.geodesics_numerical((0,0),(1,0),(0,2*pi,100))]

sage: g2 = [c[-1] for c in S.geodesics_numerical((0,0),(cos(pi/3),sin(pi/3)),(0,2*pi,100))]

sage: g3 = [c[-1] for c in S.geodesics_numerical((0,0),(cos(2*pi/3),sin(2*pi/3)),(0,2*pi,100))]

sage: (S.plot(opacity=0.3) + line3d(g1,color='red') + line3d(g2,color='red') + line3d(g3,color='red')).show()

"""

def __init__(self, equation, variables, name=None):

r"""

See ``ParametrizedSurface3D`` for full documentation.

.. note::

The orientation of the surface is determined by the

parametrization, that is, the natural frame with positive

orientation is given by `\partial_1 \vec r`, `\partial_2 \vec

r`.

EXAMPLES::

sage: u, v = var('u,v', domain='real')

sage: eq = (3*u + 3*u*v^2 - u^3, 3*v + 3*u^2*v - v^3, 3*(u^2-v^2))

sage: enneper = ParametrizedSurface3D(eq, (u, v),'Enneper Surface'); enneper

Parametrized surface ('Enneper Surface') with equation (-u^3 + 3*u*v^2 + 3*u, 3*u^2*v - v^3 + 3*v, 3*u^2 - 3*v^2)

"""

self.equation = tuple(equation)

if len(variables[0]) > 0:

self.variables_range = (variables[0][1:3], variables[1][1:3])

self.variables_list = (variables[0][0], variables[1][0])

else:

self.variables_range = None

self.variables_list = variables

self.variables = {1:self.variables_list[0],2:self.variables_list[1]}

self.name = name

def _latex_(self):

r"""

Returns the LaTeX representation of this parametrized surface.

EXAMPLES::

sage: u, v = var('u, v')

sage: sphere = ParametrizedSurface3D((cos(u)*cos(v), sin(u)*cos(v), sin(v)), (u, v),'sphere')

sage: latex(sphere)

\left(\cos\left(u\right) \cos\left(v\right), \cos\left(v\right) \sin\left(u\right), \sin\left(v\right)\right)

sage: sphere._latex_()

\left(\cos\left(u\right) \cos\left(v\right), \cos\left(v\right) \sin\left(u\right), \sin\left(v\right)\right)

"""

from sage.misc.latex import latex

return latex(self.equation)

def _repr_(self):

r"""

Returns the string representation of this parametrized surface.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: eq = (3*u + 3*u*v^2 - u^3, 3*v + 3*u^2*v - v^3, 3*(u^2-v^2))

sage: enneper = ParametrizedSurface3D(eq,[u,v],'enneper_surface')

sage: print(enneper)

Parametrized surface ('enneper_surface') with equation (-u^3 + 3*u*v^2 + 3*u, 3*u^2*v - v^3 + 3*v, 3*u^2 - 3*v^2)

sage: enneper._repr_()

"Parametrized surface ('enneper_surface') with equation (-u^3 + 3*u*v^2 + 3*u, 3*u^2*v - v^3 + 3*v, 3*u^2 - 3*v^2)"

"""

name = 'Parametrized surface'

if self.name is not None:

name += " ('%s')" % self.name

s ='%(designation)s with equation %(eq)s' % \

{'designation': name, 'eq': str(self.equation)}

return s

def point(self, coords):

r"""

Returns a point on the surface given its intrinsic coordinates.

INPUT:

- ``coords`` - 2-tuple specifying the intrinsic coordinates ``(u, v)`` of the point.

OUTPUT:

- 3-vector specifying the coordinates in `\RR^3` of the point.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: torus = ParametrizedSurface3D(((2 + cos(u))*cos(v),(2 + cos(u))*sin(v), sin(u)),[u,v],'torus')

sage: torus.point((0, pi/2))

(0, 3, 0)

sage: torus.point((pi/2, pi))

(-2, 0, 1)

sage: torus.point((pi, pi/2))

(0, 1, 0)

"""

d = dict(zip(self.variables_list, coords))

return vector([f.subs(d) for f in self.equation])

def tangent_vector(self, coords, components):

r"""

Returns the components of a tangent vector given the intrinsic

coordinates of the base point and the components of the vector

in the intrinsic frame.

INPUT:

- ``coords`` - 2-tuple specifying the intrinsic coordinates ``(u, v)`` of the point.

- ``components`` - 2-tuple specifying the components of the tangent vector in the intrinsic coordinate frame.

OUTPUT:

- 3-vector specifying the components in `\RR^3` of the vector.

EXAMPLES:

We compute two tangent vectors to Enneper's surface along the

coordinate lines and check that their cross product gives the

normal vector::

sage: u, v = var('u,v', domain='real')

sage: eq = (3*u + 3*u*v^2 - u^3, 3*v + 3*u^2*v - v^3, 3*(u^2-v^2))

sage: e = ParametrizedSurface3D(eq, (u, v),'Enneper Surface')

sage: w1 = e.tangent_vector((1, 2), (1, 0)); w1

(12, 12, 6)

sage: w2 = e.tangent_vector((1, 2), (0, 1)); w2

(12, -6, -12)

sage: w1.cross_product(w2)

(-108, 216, -216)

sage: n = e.normal_vector().subs({u: 1, v: 2}); n

(-108, 216, -216)

sage: n == w1.cross_product(w2)

True

"""

components = vector(components)

d = dict(zip(self.variables_list, coords))

jacobian = matrix([[f.diff(u).subs(d) for u in self.variables_list]

for f in self.equation])

return jacobian * components

def plot(self, urange=None, vrange=None, **kwds):

r"""

Enable easy plotting directly from the surface class.

The optional keywords ``urange`` and ``vrange`` specify the range for

the surface parameters `u` and `v`. If either of these parameters

is ``None``, the method checks whether a parameter range was

specified when the surface was created. If not, the default of

$(0, 2 \pi)$ is used.

INPUT:

- ``urange`` - 2-tuple specifying the parameter range for `u`.

- ``vrange`` - 2-tuple specifying the parameter range for `v`.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: eq = (3*u + 3*u*v^2 - u^3, 3*v + 3*u^2*v - v^3, 3*(u^2-v^2))

sage: enneper = ParametrizedSurface3D(eq, (u, v), 'Enneper Surface')

sage: enneper.plot((-5, 5), (-5, 5))

Graphics3d Object

"""

from sage.plot.plot3d.parametric_plot3d import parametric_plot3d

if self.variables_range is None:

if urange is None:

urange = (0, 2*pi)

if vrange is None:

vrange = (0, 2*pi)

else:

if urange is None:

urange = self.variables_range[0]

if vrange is None:

vrange = self.variables_range[1]

urange3 = (self.variables[1],) + tuple(urange)

vrange3 = (self.variables[2],) + tuple(vrange)

P = parametric_plot3d(self.equation, urange3, vrange3, **kwds)

return P

@cached_method

def natural_frame(self):

"""

Returns the natural tangent frame on the parametrized surface.

The vectors of this frame are tangent to the coordinate lines

on the surface.

OUTPUT:

- The natural frame as a dictionary.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: eparaboloid = ParametrizedSurface3D((u, v, u^2+v^2), (u, v), 'elliptic paraboloid')

sage: eparaboloid.natural_frame()

{1: (1, 0, 2*u), 2: (0, 1, 2*v)}

"""

dr1 = \

vector([_simplify_full_rad( diff(f,self.variables[1]) )

for f in self.equation])

dr2 = \

vector([_simplify_full_rad( diff(f,self.variables[2]) )

for f in self.equation])

return {1:dr1, 2:dr2}

@cached_method

def normal_vector(self, normalized=False):

"""

Returns the normal vector field of the parametrized surface.

INPUT:

- ``normalized`` - default ``False`` - specifies whether the normal vector should be normalized.

OUTPUT:

- Normal vector field.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: eparaboloid = ParametrizedSurface3D((u, v, u^2 + v^2), (u, v), 'elliptic paraboloid')

sage: eparaboloid.normal_vector(normalized=False)

(-2*u, -2*v, 1)

sage: eparaboloid.normal_vector(normalized=True)

(-2*u/sqrt(4*u^2 + 4*v^2 + 1), -2*v/sqrt(4*u^2 + 4*v^2 + 1), 1/sqrt(4*u^2 + 4*v^2 + 1))

"""

dr = self.natural_frame()

normal = dr[1].cross_product(dr[2])

if normalized:

normal /= normal.norm()

return _simplify_full_rad(normal)

@cached_method

def _compute_first_fundamental_form_coefficient(self, index):

"""

Helper function to compute coefficients of the first fundamental form.

Do not call this method directly; instead use

``first_fundamental_form_coefficient``.

This method is cached, and expects its argument to be a list.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: eparaboloid = ParametrizedSurface3D((u, v, u^2+v^2), (u, v))

sage: eparaboloid._compute_first_fundamental_form_coefficient((1,2))

4*u*v

"""

dr = self.natural_frame()

return _simplify_full_rad(dr[index[0]]*dr[index[1]])

def first_fundamental_form_coefficient(self, index):

r"""

Compute a single component $g_{ij}$ of the first fundamental form. If

the parametric representation of the surface is given by the vector

function $\vec r(u^i)$, where $u^i$, $i = 1, 2$ are curvilinear

coordinates, then $g_{ij} = \frac{\partial \vec r}{\partial u^i} \cdot \frac{\partial \vec r}{\partial u^j}$.

INPUT:

- ``index`` - tuple ``(i, j)`` specifying the index of the component $g_{ij}$.

OUTPUT:

- Component $g_{ij}$ of the first fundamental form

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: eparaboloid = ParametrizedSurface3D((u, v, u^2+v^2), (u, v))

sage: eparaboloid.first_fundamental_form_coefficient((1,2))

4*u*v

When the index is invalid, an error is raised::

sage: u, v = var('u, v', domain='real')

sage: eparaboloid = ParametrizedSurface3D((u, v, u^2+v^2), (u, v))

sage: eparaboloid.first_fundamental_form_coefficient((1,5))

Traceback (most recent call last):

...

ValueError: Index (1, 5) out of bounds.

"""

index = tuple(sorted(index))

if len(index) == 2 and all(i == 1 or i == 2 for i in index):

return self._compute_first_fundamental_form_coefficient(index)

else:

raise ValueError("Index %s out of bounds." % str(index))

def first_fundamental_form_coefficients(self):

r"""

Returns the coefficients of the first fundamental form as a dictionary.

The keys are tuples $(i, j)$, where $i$ and $j$ range over $1, 2$,

while the values are the corresponding coefficients $g_{ij}$.

OUTPUT:

- Dictionary of first fundamental form coefficients.

EXAMPLES::

sage: u, v = var('u,v', domain='real')

sage: sphere = ParametrizedSurface3D((cos(u)*cos(v), sin(u)*cos(v), sin(v)), (u, v), 'sphere')

sage: sphere.first_fundamental_form_coefficients()

{(1, 1): cos(v)^2, (1, 2): 0, (2, 1): 0, (2, 2): 1}

"""

coefficients = {}

for index in product((1, 2), repeat=2):

sorted_index = list(sorted(index))

coefficients[index] = \

self._compute_first_fundamental_form_coefficient(index)

return coefficients

def first_fundamental_form(self, vector1, vector2):

r"""

Evaluate the first fundamental form on two vectors expressed with

respect to the natural coordinate frame on the surface. In other words,

if the vectors are $v = (v^1, v^2)$ and $w = (w^1, w^2)$, calculate

$g_{11} v^1 w^1 + g_{12}(v^1 w^2 + v^2 w^1) + g_{22} v^2 w^2$, with

$g_{ij}$ the coefficients of the first fundamental form.

INPUT:

- ``vector1``, ``vector2`` - vectors on the surface.

OUTPUT:

- First fundamental form evaluated on the input vectors.

EXAMPLES::

sage: u, v = var('u, v', domain='real')

sage: v1, v2, w1, w2 = var('v1, v2, w1, w2', domain='real')

sage: sphere = ParametrizedSurface3D((cos(u)*cos(v), sin(u)*cos(v), sin(v)), (u, v),'sphere')

sage: sphere.first_fundamental_form(vector([v1,v2]),vector([w1,w2]))

v1*w1*cos(v)^2 + v2*w2

sage: vv = vector([1,2])

sage: sphere.first_fundamental_form(vv,vv)

cos(v)^2 + 4

sage: sphere.first_fundamental_form([1,1],[2,1])

2*cos(v)^2 + 1

"""

gamma = self.first_fundamental_form_coefficients()

return sum(gamma[(i,j)] * vector1[i - 1] * vector2[j - 1]

for i, j in product((1, 2), repeat=2))

def area_form_squared(self):

"""

Returns the square of the coefficient of the area form on the surface.

In terms of the coefficients $g_{ij}$ (where $i, j = 1, 2$) of the

first fundamental form, this invariant is given by

$A^2 = g_{11}g_{22} - g_{12}^2$.

Coverage for local/lib/python2.7/site-packages/sage/geometry/riemannian_manifolds/parametrized_surface3d.py : 98%

259 statements 253 run 6 missing 0 excluded