o o hQ@srddlmZddlmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZmZdd lmZdd lmZdd lmZdd l m!Z"dd l#m$Z$ddl%m&Z&m'Z'm(Z(ddl)m*Z*Gddde Z+Gddde Z,Gddde Z-GdddeZ.Gddde Z/Gddde Z0Gddde Z1ddZ2Gd d!d!e Z3Gd"d#d#e Z4Gd$d%d%e Z5Gd&d'd'e5Z6Gd(d)d)e Z7Gd*d+d+e Z8Gd,d-d-e Z9dNd1d2Z:dOd3d4Z;d5d6Zd;d<Z?d=d>Z@d?d@ZAdAdBZBdCdDZCdEdFZDGdGdHdHZEGdIdJdJeEeFZGGdKdLdLeEeHZIddMlJmKZKd/S)Q) annotations)Anyreduce) permutations) Permutation) BasicExprFunctiondiffPowMulAddLambdaSTupleDict)cacheit)SymbolDummy)Str)_sympify factorial)ImmutableDenseMatrix)solve)sympy_deprecation_warningSymPyDeprecationWarningignore_warnings)ImmutableDenseNDimArraycs8eZdZdZfddZeddZeddZZS)Manifolda A mathematical manifold. Explanation =========== A manifold is a topological space that locally resembles Euclidean space near each point [1]. This class does not provide any means to study the topological characteristics of the manifold that it represents, though. Parameters ========== name : str The name of the manifold. dim : int The dimension of the manifold. Examples ======== >>> from sympy.diffgeom import Manifold >>> m = Manifold('M', 2) >>> m M >>> m.dim 2 References ========== .. [1] https://en.wikipedia.org/wiki/Manifold c s:t|ts t|}t|}t|||}tdg|_|S)Nz Manifold.patches is deprecated. The Manifold object is now immutable. Instead use a separate list to keep track of the patches. ) isinstancerrsuper__new___deprecated_listpatches)clsnamedimkwargsobj __class__k/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/diffgeom/diffgeom.pyr#Fs zManifold.__new__cC |jdSNrargsselfr-r-r.r'T z Manifold.namecCr/Nr1r3r-r-r.r(Xr5z Manifold.dim) __name__ __module__ __qualname____doc__r#propertyr'r( __classcell__r-r-r+r.r !s $ r csDeZdZdZfddZeddZeddZedd ZZ S) Patcha A patch on a manifold. Explanation =========== Coordinate patch, or patch in short, is a simply-connected open set around a point in the manifold [1]. On a manifold one can have many patches that do not always include the whole manifold. On these patches coordinate charts can be defined that permit the parameterization of any point on the patch in terms of a tuple of real numbers (the coordinates). This class does not provide any means to study the topological characteristics of the patch that it represents. Parameters ========== name : str The name of the patch. manifold : Manifold The manifold on which the patch is defined. Examples ======== >>> from sympy.diffgeom import Manifold, Patch >>> m = Manifold('M', 2) >>> p = Patch('P', m) >>> p P >>> p.dim 2 References ========== .. [1] G. Sussman, J. Wisdom, W. Farr, Functional Differential Geometry (2013) c s@t|ts t|}t|||}|jj|tdg|_|S)Nz Patch.coord_systms is deprecated. The Patch class is now immutable. Instead use a separate list to keep track of coordinate systems. ) r!rr"r#manifoldr%appendr$ coord_systems)r&r'r?r)r*r+r-r.r#s z Patch.__new__cCr/r0r1r3r-r-r.r'r5z Patch.namecCr/r6r1r3r-r-r.r?r5zPatch.manifoldcC|jjSNr?r(r3r-r-r.r(z Patch.dim) r8r9r:r;r#r<r'r?r(r=r-r-r+r.r>]s *  r>cs>eZdZdZdiffdd ZeddZeddZed d Zed d Z ed dZ eddZ ddZ e ddZeddZeeddZe ddZd;ddZe dd Ze d!d"Zd>> from sympy import symbols, pi, sqrt, atan2, cos, sin >>> from sympy.diffgeom import Manifold, Patch, CoordSystem >>> m = Manifold('M', 2) >>> p = Patch('P', m) >>> x, y = symbols('x y', real=True) >>> r, theta = symbols('r theta', nonnegative=True) >>> relation_dict = { ... ('Car2D', 'Pol'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))], ... ('Pol', 'Car2D'): [(r, theta), (r*cos(theta), r*sin(theta))] ... } >>> Car2D = CoordSystem('Car2D', p, (x, y), relation_dict) >>> Pol = CoordSystem('Pol', p, (r, theta), relation_dict) ``symbols`` property returns ``CoordinateSymbol`` instances. These symbols are not same with the symbols used to construct the coordinate system. >>> Car2D Car2D >>> Car2D.dim 2 >>> Car2D.symbols (x, y) >>> _[0].func ``transformation()`` method returns the transformation function from one coordinate system to another. ``transform()`` method returns the transformed coordinates. >>> Car2D.transformation(Pol) Lambda((x, y), Matrix([ [sqrt(x**2 + y**2)], [ atan2(y, x)]])) >>> Car2D.transform(Pol) Matrix([ [sqrt(x**2 + y**2)], [ atan2(y, x)]]) >>> Car2D.transform(Pol, [1, 2]) Matrix([ [sqrt(5)], [atan(2)]]) ``jacobian()`` method returns the Jacobian matrix of coordinate transformation between two systems. ``jacobian_determinant()`` method returns the Jacobian determinant of coordinate transformation between two systems. >>> Pol.jacobian(Car2D) Matrix([ [cos(theta), -r*sin(theta)], [sin(theta), r*cos(theta)]]) >>> Pol.jacobian(Car2D, [1, pi/2]) Matrix([ [0, -1], [1, 0]]) >>> Car2D.jacobian_determinant(Pol) 1/sqrt(x**2 + y**2) >>> Car2D.jacobian_determinant(Pol, [1,0]) 1 References ========== .. [1] https://en.wikipedia.org/wiki/Coordinate_system Nc stts t|durF|dd}|dur&tfddt|jD}n[td|dddd|Ddd d d td d|D}n;g}|D]2}t|tr`| t|j fi|j j qJt|t r|td |d|dd d d | t|ddqJt|}i} |D]?\} } | \} } t| tst| } t| tst| } t| | }t| trt| jt| jf} n t| dt| df} | | |<qt| }t||||}tdi|_dd|D|_|jj |dd|D|_t|_|S)Nnamescs"g|] }tdj|fddqS)z%s_%sTreal)rr'.0ir'r-r. sz'CoordSystem.__new__..zx The 'names' argument to CoordSystem is deprecated. Use 'symbols' instead. That is, replace CoordSystem(..., names=z') with CoordSystem(..., symbols=[z, cSsg|] }dt|dqS)zSymbol(z , real=True))reprrKnr-r-r.rN'z]) 1.7deprecated-diffgeom-mutabledeprecated_since_versionactive_deprecations_targetcSsg|]}t|ddqS)TrH)rrPr-r-r.rN-z Passing a string as the coordinate symbol name to CoordSystem is deprecated. Pass a Symbol with the appropriate name and assumptions instead. That is, replace z with Symbol(z&, real=True). TrHrr7z CoordSystem.transforms is deprecated. The CoordSystem class is now immutable. Use the 'relations' keyword argument to the CoordSystems() constructor to specify relations. cSg|]}t|qSr-)strrPr-r-r.rN`cSsg|]}tt|qSr-)rrZrPr-r-r.rNbrX)r!rgetrranger(rjoinrr@r' _assumptions generatorrZitemsrtuple signatureexprrr"r#_deprecated_dict transforms_namespatchrA_dummiesr_dummy)r&r'rhsymbols relationsr)rGsymssrel_tempkvs1s2keyr*r+rMr.r#s|             zCoordSystem.__new__cCr/r0r1r3r-r-r.r'gr5zCoordSystem.namecCr/r6r1r3r-r-r.rhkr5zCoordSystem.patchcCrBrC)rhr?r3r-r-r.r?orEzCoordSystem.manifoldcs tfddtjdDS)Nc3s*|]\}}t|fi|jjVqdSrC)CoordinateSymbolr_r`)rKrLrnr3r-r. usz&CoordSystem.symbols..)rb enumerater2r3r-r3r.rkss  zCoordSystem.symbolscCr/)Nr1r3r-r-r.rlxr5zCoordSystem.relationscCrBrC)rhr(r3r-r-r.r(|rEzCoordSystem.dimcCs|jd}t|j|j}||krt|j}n*||jvr%t|j|d}n|ddd|jvr8t|||}nt|||}t||S)a Return coordinate transformation function from *self* to *sys*. Parameters ========== sys : CoordSystem Returns ======= sympy.Lambda Examples ======== >>> from sympy.diffgeom.rn import R2_r, R2_p >>> R2_r.transformation(R2_p) Lambda((x, y), Matrix([ [sqrt(x**2 + y**2)], [ atan2(y, x)]])) rwr7N) r2rr'Matrixrkrl_inverse_transformation_indirect_transformationr)r4sysrcrtrdr-r-r.transformations    zCoordSystem.transformationcCsjtddt||Dt|dd}t|dkr!d}t|||t|dkr1d}t||||dS) NcSg|] }|d|dqSrr7r-rKtr-r-r.rNrRz.CoordSystem._solve_inverse..Tdictrz,Cannot solve inverse relation from {} to {}.r7z1Obtained multiple inverse relation from {} to {}.)rziplistlenNotImplementedErrorformat ValueError)sym1sym2exprs sys1_name sys2_namerettempr-r-r._solve_inverses  zCoordSystem._solve_inversecs@||}||j|j||j|jt|j}fdd|DS)Ncg|]}|qSr-r-rKrn inv_resultsr-r.rNr[z7CoordSystem._inverse_transformation..) transformrrkr'rb)r&sys1sys2forwardrcr-rr.r|s  z#CoordSystem._inverse_transformationc s|j}|||}g}t||ddD]@\}}||f|vr(||||fq|||f\}} tdd|D} ||| | ||tfdd|D|| fq|jd} | |D]\} tfdd| Dq^S)Nr7css|]}tVqdSrC)rrJr-r-r.rvsz7CoordSystem._indirect_transformation..c3s|]}|VqdSrCr-r)rr-r.rvrwc3s |] }|tVqdSrC)subsrrKe)rnewsymsr-r.rv)rl _dijkstrarr@rbrr2) r&rrrelpathrfrrrsr inv_exprsrrmnewexprsr-)rrrr.r}s     z$CoordSystem._indirect_transformationc s,|j}i|D]&\}}|vr|h|<n|||vr(|h|<q ||q ddDfdd}||j tdddd }d}D]\}} d | d krf|krrnqV| d sr| d }|}qV|durxn||qD|jd } | |j| |jgkrtd | S) NcSsi|]}|dgdgqSrr-)rKr~r-r-r. rXz)CoordSystem._dijkstra..csd|d<|D]3}|dd}|d|ks"|ds=||d<t|d|d<|d|q dS)Nr7rwr)rr@)r~newsysdistancegraph path_dictr-r.visits   z$CoordSystem._dijkstra..visitTcSs|dSr0r-)xr-r-r.sz'CoordSystem._dijkstra..)rtrrwr7z)Two coordinate systems are not connected.) rlkeysaddr'maxvaluesrar@KeyError) rrrlrrrsr min_distancerr~lstresultr-rr.rs:   $  zCoordSystem._dijkstraTFcCs\tddddt||\}}t|t|f|j|<|r$||||j|<|r,|dSdS)Nz The CoordSystem.connect_to() method is deprecated. Instead, generate a new instance of CoordSystem with the 'relations' keyword argument (CoordSystem classes are now immutable). rSrTrU)rdummyfyr{rf _inv_transf_fill_gaps_in_transformations)r4to_sys from_coordsto_exprsinverse fill_in_gapsr-r-r. connect_to s  zCoordSystem.connect_tocsVdd|D}tddt||Dt|dddfdd|Dt|tfS)NcSg|]}|qSr-as_dummyrJr-r-r.rN r[z+CoordSystem._inv_transf..cSrrr-rr-r-r.rN"rRTrrcrr-r-)rKfcinv_tor-r.rN$r[)rrrr{)rrinv_fromr-rr.rszCoordSystem._inv_transfcCstrC)rr-r-r-r.r'sz)CoordSystem._fill_gaps_in_transformationscCs8|dur|j}||kr||}||}|St|}|S)a Return the result of coordinate transformation from *self* to *sys*. If coordinates are not given, coordinate symbols of *self* are used. Parameters ========== sys : CoordSystem coordinates : Any iterable, optional. Returns ======= sympy.ImmutableDenseMatrix containing CoordinateSymbol Examples ======== >>> from sympy.diffgeom.rn import R2_r, R2_p >>> R2_r.transform(R2_p) Matrix([ [sqrt(x**2 + y**2)], [ atan2(y, x)]]) >>> R2_r.transform(R2_p, [0, 1]) Matrix([ [ 1], [pi/2]]) N)rkrr{)r4r~ coordinatestransfr-r-r.r0s zCoordSystem.transformcCsptddddt|}||kr6tt |j|}Wdn1s#wY|dtt|d|}|S)z0Transform ``coords`` to coord system ``to_sys``.z The CoordSystem.coord_tuple_transform_to() method is deprecated. Use the CoordSystem.transform() method instead. rSrTrUNr7r)rr{rrrfrrr)r4rcoordsrr-r-r.coord_tuple_transform_toXs   z$CoordSystem.coord_tuple_transform_tocCs4|||j}|dur|tt|j|}|S)a Return the jacobian matrix of a transformation on given coordinates. If coordinates are not given, coordinate symbols of *self* are used. Parameters ========== sys : CoordSystem coordinates : Any iterable, optional. Returns ======= sympy.ImmutableDenseMatrix Examples ======== >>> from sympy.diffgeom.rn import R2_r, R2_p >>> R2_p.jacobian(R2_r) Matrix([ [cos(theta), -rho*sin(theta)], [sin(theta), rho*cos(theta)]]) >>> R2_p.jacobian(R2_r, [1, 0]) Matrix([ [1, 0], [0, 1]]) N)rjacobianrkrrr)r4r~rrr-r-r.rjszCoordSystem.jacobiancCs|||S)a6 Return the jacobian determinant of a transformation on given coordinates. If coordinates are not given, coordinate symbols of *self* are used. Parameters ========== sys : CoordSystem coordinates : Any iterable, optional. Returns ======= sympy.Expr Examples ======== >>> from sympy.diffgeom.rn import R2_r, R2_p >>> R2_r.jacobian_determinant(R2_p) 1/sqrt(x**2 + y**2) >>> R2_r.jacobian_determinant(R2_p, [1, 0]) 1 )rdet)r4r~rr-r-r.jacobian_determinantsz CoordSystem.jacobian_determinantcC t||S)z?Create a ``Point`` with coordinates given in this coord system.)Point)r4rr-r-r.pointr5zCoordSystem.pointcC ||S)z:Calculate the coordinates of a point in this coord system.)r)r4rr-r-r.point_to_coordsr5zCoordSystem.point_to_coordscCr)zQReturn ``BaseScalarField`` that takes a point and returns one of the coordinates.)BaseScalarFieldr4 coord_indexr-r-r. base_scalarr5zCoordSystem.base_scalarcfddtjDS)zrReturns a list of all coordinate functions. For more details see the ``base_scalar`` method of this class.cg|]}|qSr-)rrJr3r-r.rNz,CoordSystem.base_scalars..r]r(r3r-r3r. base_scalarszCoordSystem.base_scalarscCr)zReturn a basis vector field. The basis vector field for this coordinate system. It is also an operator on scalar fields.)BaseVectorFieldrr-r-r. base_vectors zCoordSystem.base_vectorcr)zjReturns a list of all base vectors. For more details see the ``base_vector`` method of this class.crr-)rrJr3r-r.rNrz,CoordSystem.base_vectors..rr3r-r3r. base_vectorsrzCoordSystem.base_vectorscCst||S)zReturn a basis 1-form field. The basis one-form field for this coordinate system. It is also an operator on vector fields.) Differentialcoord_functionrr-r-r. base_oneformszCoordSystem.base_oneformcr)zlReturns a list of all base oneforms. For more details see the ``base_oneform`` method of this class.crr-)rrJr3r-r.rNrz-CoordSystem.base_oneforms..rr3r-r3r. base_oneformsrzCoordSystem.base_oneforms)TFrC)'r8r9r:r;r#r<r'rhr?rkrlr(r staticmethodr classmethodr|rr}rrrrrrrjacobian_matrixrrrrrrcoord_functionsrrrrr=r-r-r+r.rFsZmV      %     /   ( # #rFcs<eZdZdZfddZddZddZfdd ZZS) ruaA symbol which denotes an abstract value of i-th coordinate of the coordinate system with given context. Explanation =========== Each coordinates in coordinate system are represented by unique symbol, such as x, y, z in Cartesian coordinate system. You may not construct this class directly. Instead, use `symbols` method of CoordSystem. Parameters ========== coord_sys : CoordSystem index : integer Examples ======== >>> from sympy import symbols, Lambda, Matrix, sqrt, atan2, cos, sin >>> from sympy.diffgeom import Manifold, Patch, CoordSystem >>> m = Manifold('M', 2) >>> p = Patch('P', m) >>> x, y = symbols('x y', real=True) >>> r, theta = symbols('r theta', nonnegative=True) >>> relation_dict = { ... ('Car2D', 'Pol'): Lambda((x, y), Matrix([sqrt(x**2 + y**2), atan2(y, x)])), ... ('Pol', 'Car2D'): Lambda((r, theta), Matrix([r*cos(theta), r*sin(theta)])) ... } >>> Car2D = CoordSystem('Car2D', p, [x, y], relation_dict) >>> Pol = CoordSystem('Pol', p, [r, theta], relation_dict) >>> x, y = Car2D.symbols ``CoordinateSymbol`` contains its coordinate symbol and index. >>> x.name 'x' >>> x.coord_sys == Car2D True >>> x.index 0 >>> x.is_real True You can transform ``CoordinateSymbol`` into other coordinate system using ``rewrite()`` method. >>> x.rewrite(Pol) r*cos(theta) >>> sqrt(x**2 + y**2).rewrite(Pol).simplify() r c s6|jd|j}tj||fi|}||_||_|SNrw)r2r'r"r# coord_sysindex)r&rr assumptionsr'r*r+r-r.r#s zCoordinateSymbol.__new__cCs |j|jfSrC)rrr3r-r-r.__getnewargs__ s zCoordinateSymbol.__getnewargs__cCs|j|jftt|jSrC)rrrbsorted assumptions0rar3r-r-r._hashable_content#sz"CoordinateSymbol._hashable_contentc s2t|tr||j|jStj||fi|SrC)r!rFrrrr" _eval_rewrite)r4ruler2hintsr+r-r.r(s zCoordinateSymbol._eval_rewrite) r8r9r:r;r#rrrr=r-r-r+r.rus  8rucsZeZdZdZfddZeddZeddZedd Zdd d Z ed dZ Z S)raPoint defined in a coordinate system. Explanation =========== Mathematically, point is defined in the manifold and does not have any coordinates by itself. Coordinate system is what imbues the coordinates to the point by coordinate chart. However, due to the difficulty of realizing such logic, you must supply a coordinate system and coordinates to define a Point here. The usage of this object after its definition is independent of the coordinate system that was used in order to define it, however due to limitations in the simplification routines you can arrive at complicated expressions if you use inappropriate coordinate systems. Parameters ========== coord_sys : CoordSystem coords : list The coordinates of the point. Examples ======== >>> from sympy import pi >>> from sympy.diffgeom import Point >>> from sympy.diffgeom.rn import R2, R2_r, R2_p >>> rho, theta = R2_p.symbols >>> p = Point(R2_p, [rho, 3*pi/4]) >>> p.manifold == R2 True >>> p.coords() Matrix([ [ rho], [3*pi/4]]) >>> p.coords(R2_r) Matrix([ [-sqrt(2)*rho/2], [ sqrt(2)*rho/2]]) c (t|}t|||}||_||_|SrC)r{r"r# _coord_sys_coords)r&rrr)r*r+r-r.r#^ z Point.__new__cCrBrC)rrhr3r-r-r.rherEz Point.patchcCrBrC)rr?r3r-r-r.r?irEzPoint.manifoldcCrBrCrDr3r-r-r.r(mrEz Point.dimNcCs|dur|jS|j||jS)z Coordinates of the point in given coordinate system. If coordinate system is not passed, it returns the coordinates in the coordinate system in which the poin was defined. N)rrr)r4r~r-r-r.rqsz Point.coordscCrBrC)r free_symbolsr3r-r-r.r|rEzPoint.free_symbolsrC) r8r9r:r;r#r<rhr?r(rrr=r-r-r+r.r.s /     rcsxeZdZUdZdZfddZeddZeddZed d Z ed d Z ed dZ ddZ e Zded<ZS)raBase scalar field over a manifold for a given coordinate system. Explanation =========== A scalar field takes a point as an argument and returns a scalar. A base scalar field of a coordinate system takes a point and returns one of the coordinates of that point in the coordinate system in question. To define a scalar field you need to choose the coordinate system and the index of the coordinate. The use of the scalar field after its definition is independent of the coordinate system in which it was defined, however due to limitations in the simplification routines you may arrive at more complicated expression if you use unappropriate coordinate systems. You can build complicated scalar fields by just building up SymPy expressions containing ``BaseScalarField`` instances. Parameters ========== coord_sys : CoordSystem index : integer Examples ======== >>> from sympy import Function, pi >>> from sympy.diffgeom import BaseScalarField >>> from sympy.diffgeom.rn import R2_r, R2_p >>> rho, _ = R2_p.symbols >>> point = R2_p.point([rho, 0]) >>> fx, fy = R2_r.base_scalars() >>> ftheta = BaseScalarField(R2_r, 1) >>> fx(point) rho >>> fy(point) 0 >>> (fx**2+fy**2).rcall(point) rho**2 >>> g = Function('g') >>> fg = g(ftheta-pi) >>> fg.rcall(point) g(-pi) Tc rrCrr"r#r_indexr&rrr)r*r+r-r.r#rzBaseScalarField.__new__cCr/r0r1r3r-r-r.rr5zBaseScalarField.coord_syscCr/r6r1r3r-r-r.rr5zBaseScalarField.indexcCrBrCrrhr3r-r-r.rhrEzBaseScalarField.patchcCrBrCrr?r3r-r-r.r?rEzBaseScalarField.manifoldcCrBrCrDr3r-r-r.r(rEzBaseScalarField.dimcGs@|d}t|dkst|ts|S||j}t||jS)aeEvaluating the field at a point or doing nothing. If the argument is a ``Point`` instance, the field is evaluated at that point. The field is returned itself if the argument is any other object. It is so in order to have working recursive calling mechanics for all fields (check the ``__call__`` method of ``Expr``). rr7)rr!rrrsimplifyrdoit)r4r2rrr-r-r.__call__s  zBaseScalarField.__call__zset[Any]r)r8r9r:r;is_commutativer#r<rrrhr?r(rsetr__annotations__r=r-r-r+r.rs 4      rcsheZdZdZdZfddZeddZeddZed d Z ed d Z ed dZ ddZ Z S)raqBase vector field over a manifold for a given coordinate system. Explanation =========== A vector field is an operator taking a scalar field and returning a directional derivative (which is also a scalar field). A base vector field is the same type of operator, however the derivation is specifically done with respect to a chosen coordinate. To define a base vector field you need to choose the coordinate system and the index of the coordinate. The use of the vector field after its definition is independent of the coordinate system in which it was defined, however due to limitations in the simplification routines you may arrive at more complicated expression if you use unappropriate coordinate systems. Parameters ========== coord_sys : CoordSystem index : integer Examples ======== >>> from sympy import Function >>> from sympy.diffgeom.rn import R2_p, R2_r >>> from sympy.diffgeom import BaseVectorField >>> from sympy import pprint >>> x, y = R2_r.symbols >>> rho, theta = R2_p.symbols >>> fx, fy = R2_r.base_scalars() >>> point_p = R2_p.point([rho, theta]) >>> point_r = R2_r.point([x, y]) >>> g = Function('g') >>> s_field = g(fx, fy) >>> v = BaseVectorField(R2_r, 1) >>> pprint(v(s_field)) / d \| |---(g(x, xi))|| \dxi /|xi=y >>> pprint(v(s_field).rcall(point_r).doit()) d --(g(x, y)) dy >>> pprint(v(s_field).rcall(point_p)) / d \| |---(g(rho*cos(theta), xi))|| \dxi /|xi=rho*sin(theta) Fc rrCrrr+r-r.r#"rzBaseVectorField.__new__cCr/r0r1r3r-r-r.r)r5zBaseVectorField.coord_syscCr/r6r1r3r-r-r.r-r5zBaseVectorField.indexcCrBrCrr3r-r-r.rh1rEzBaseVectorField.patchcCrBrCrr3r-r-r.r?5rEzBaseVectorField.manifoldcCrBrCrDr3r-r-r.r(9rEzBaseVectorField.dimc st|st|r td|dur|St|t}|jjfddt|D}| tt ||}| }|jj }fdd|D}g}|D]}|j |j|} || |j|jfqH| tt ||}| tt ||} | tt ||j} | S)zApply on a scalar field. The action of a vector field on a scalar field is a directional differentiation. If the argument is not a scalar field an error is raised. zAOnly scalar fields can be supplied as arguments to vector fields.Nc g|] \}}td|qSz_#_%sr rKrLbd_varr-r.rNN z,BaseVectorField.__call__..csg|]}|qSr-)r rKfr r-r.rNUr)covariant_ordercontravariant_orderrratomsrrrjrxrrr rkrr@rrr) r4 scalar_fieldrd_funcsd_resultr d_funcs_derivd_funcs_deriv_subr jacrr-r r.r=s*  zBaseVectorField.__call__)r8r9r:r;rr#r<rrrhr?r(rr=r-r-r+r.rs9      rcCs|tt}dd|DS)NcSh|]}|jqSr-rr r-r-r. ez_find_coords..)rrr)rdfieldsr-r-r. _find_coordsbs rc@eZdZdZfddZeddZeddZdd ZZ S) Commutatora#Commutator of two vector fields. Explanation =========== The commutator of two vector fields `v_1` and `v_2` is defined as the vector field `[v_1, v_2]` that evaluated on each scalar field `f` is equal to `v_1(v_2(f)) - v_2(v_1(f))`. Examples ======== >>> from sympy.diffgeom.rn import R2_p, R2_r >>> from sympy.diffgeom import Commutator >>> from sympy import simplify >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> e_r = R2_p.base_vector(0) >>> c_xy = Commutator(e_x, e_y) >>> c_xr = Commutator(e_x, e_r) >>> c_xy 0 Unfortunately, the current code is not able to compute everything: >>> c_xr Commutator(e_x, e_rho) >>> simplify(c_xr(fy**2)) -2*cos(theta)*y**2/(x**2 + y**2) cs.tstdkststdkrtdkrtjStjddfD}t|dkrtddfDr@tjSddfD\}}fdd|D}fd d|D}d }t ||D] \} } t ||D]\} } || | | | | | | | 7}qmqd|St |} | _ | _ | S) Nr7z0Only commutators of vector fields are supported.cSrYr-)rrKrqr-r-r.rNr[z&Commutator.__new__..css|]}t|tVqdSrC)r!rr r-r-r.rvsz%Commutator.__new__..cSsg|] }t|tqSr-)rrrr r-r-r.rNscg|] }|qSr-expandcoeffrKr )v1r-r.rNcr!r-r"r%v2r-r.rNr'r)rrrrZerorunionrallrr"r#_v1_v2)r&r&r)rbases_1bases_2coeffs_1coeffs_2resc1b1c2b2r*r+r&r)r.r#s8   &zCommutator.__new__cCr/r0r1r3r-r-r.r&r5z Commutator.v1cCr/r6r1r3r-r-r.r)r5z Commutator.v2cCs ||||||S)zcApply on a scalar field. If the argument is not a scalar field an error is raised. r8)r4rr-r-r.rs zCommutator.__call__) r8r9r:r;r#r<r&r)rr=r-r-r+r.rhs "  rcs8eZdZdZdZfddZeddZddZZ S) raReturn the differential (exterior derivative) of a form field. Explanation =========== The differential of a form (i.e. the exterior derivative) has a complicated definition in the general case. The differential `df` of the 0-form `f` is defined for any vector field `v` as `df(v) = v(f)`. Examples ======== >>> from sympy import Function >>> from sympy.diffgeom.rn import R2_r >>> from sympy.diffgeom import Differential >>> from sympy import pprint >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> g = Function('g') >>> s_field = g(fx, fy) >>> dg = Differential(s_field) >>> dg d(g(x, y)) >>> pprint(dg(e_x)) / d \| |---(g(xi, y))|| \dxi /|xi=x >>> pprint(dg(e_y)) / d \| |---(g(x, xi))|| \dxi /|xi=y Applying the exterior derivative operator twice always results in: >>> Differential(dg) 0 Fcs8t|rtdt|trtjSt||}||_|S)Nz;A vector field was supplied as an argument to Differential.) rrr!rrr*r"r# _form_field)r& form_fieldr*r+r-r.r#s zDifferential.__new__cCr/r0r1r3r-r-r.r:r5zDifferential.form_fieldc Gstdd|Dr tdt|}|dkr#|dr!|d|jS|S|j}|}d}t|D][}|||j|d|||dd}|d||7}t|d|D]3}t||||} | r|j| f|d|||d|||dd}|d|||7}qUq.|S)aApply on a list of vector_fields. Explanation =========== If the number of vector fields supplied is not equal to 1 + the order of the form field inside the differential the result is undefined. For 1-forms (i.e. differentials of scalar fields) the evaluation is done as `df(v)=v(f)`. However if `v` is ``None`` instead of a vector field, the differential is returned unchanged. This is done in order to permit partial contractions for higher forms. In the general case the evaluation is done by applying the form field inside the differential on a list with one less elements than the number of elements in the original list. Lowering the number of vector fields is achieved through replacing each pair of fields by their commutator. If the arguments are not vectors or ``None``s an error is raised. css,|]}t|dkst|o|duVqdS)r7N)rrrKar-r-r.rvs$z(Differential.__call__..zHThe arguments supplied to Differential should be vector fields or Nones.r7rNrz)anyrrrcallr9r]r) r4 vector_fieldsrprrqrrLrjcr-r-r.rs. ,8zDifferential.__call__) r8r9r:r;rr#r<r:rr=r-r-r+r.rs)  rcs(eZdZdZfddZddZZS) TensorProductaTensor product of forms. Explanation =========== The tensor product permits the creation of multilinear functionals (i.e. higher order tensors) out of lower order fields (e.g. 1-forms and vector fields). However, the higher tensors thus created lack the interesting features provided by the other type of product, the wedge product, namely they are not antisymmetric and hence are not form fields. Examples ======== >>> from sympy.diffgeom.rn import R2_r >>> from sympy.diffgeom import TensorProduct >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> dx, dy = R2_r.base_oneforms() >>> TensorProduct(dx, dy)(e_x, e_y) 1 >>> TensorProduct(dx, dy)(e_y, e_x) 0 >>> TensorProduct(dx, fx*dy)(fx*e_x, e_y) x**2 >>> TensorProduct(e_x, e_y)(fx**2, fy**2) 4*x*y >>> TensorProduct(e_y, dx)(fy) dx You can nest tensor products. >>> tp1 = TensorProduct(dx, dy) >>> TensorProduct(tp1, dx)(e_x, e_y, e_x) 1 You can make partial contraction for instance when 'raising an index'. Putting ``None`` in the second argument of ``rcall`` means that the respective position in the tensor product is left as it is. >>> TP = TensorProduct >>> metric = TP(dx, dx) + 3*TP(dy, dy) >>> metric.rcall(e_y, None) 3*dy Or automatically pad the args with ``None`` without specifying them. >>> metric.rcall(e_y) 3*dy csXtdd|D}dd|D}|r*t|dkr||dS|tj|g|RS|S)NcSs$g|]}t|t|dkr|qSrrrrKmr-r-r.rN[s$z)TensorProduct.__new__..cSs g|] }t|t|r|qSr-rCrDr-r-r.rN\ r7r)r rr"r#)r&r2scalar multifieldsr+r-r.r#Zs  zTensorProduct.__new__cst|t|}t}||krtdg||dd|jDfddttdD}fddtdg||dgDddt|jD}t|S) aApply on a list of fields. If the number of input fields supplied is not equal to the order of the tensor product field, the list of arguments is padded with ``None``'s. The list of arguments is divided in sublists depending on the order of the forms inside the tensor product. The sublists are provided as arguments to these forms and the resulting expressions are given to the constructor of ``TensorProduct``. NcSsg|] }t|t|qSr-rCr r-r-r.rNtrRz*TensorProduct.__call__..cs g|] }td|dqSr6sumrJ)ordersr-r.rNurFr7csg|] \}}||qSr-r-)rKrLr@)rr-r.rNvrRrcSsg|] }|dj|dqSrr>rr-r-r.rNws)rrrr_argsr]rrB)r4r tot_ordertot_argsindices multipliersr-)rrKr.rds $zTensorProduct.__call__)r8r9r:r;r#rr=r-r-r+r.rB$s 5 rBc@seZdZdZddZdS) WedgeProductaWedge product of forms. Explanation =========== In the context of integration only completely antisymmetric forms make sense. The wedge product permits the creation of such forms. Examples ======== >>> from sympy.diffgeom.rn import R2_r >>> from sympy.diffgeom import WedgeProduct >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> dx, dy = R2_r.base_oneforms() >>> WedgeProduct(dx, dy)(e_x, e_y) 1 >>> WedgeProduct(dx, dy)(e_y, e_x) -1 >>> WedgeProduct(dx, fx*dy)(fx*e_x, e_y) x**2 >>> WedgeProduct(e_x, e_y)(fy, None) -e_x You can nest wedge products. >>> wp1 = WedgeProduct(dx, dy) >>> WedgeProduct(wp1, dx)(e_x, e_y, e_x) 0 csrdd|jD}dtdd|D}t|}ddttt|D}t|j|tfddt||DS)z{Apply on a list of vector_fields. The expression is rewritten internally in terms of tensor products and evaluated.css |] }t|t|VqdSrCrCrr-r-r.rvrz(WedgeProduct.__call__..r7cs|]}t|VqdSrCrrKor-r-r.rvrcss|] }t|VqdSrC)rrcrKpr-r-r.rvs cs g|] }|d|dqSrr-rV tensor_prodr-r.rNrFz)WedgeProduct.__call__..)r2r rr]rrBrr)r4rrKmulperms perms_parr-rXr.rs  zWedgeProduct.__call__N)r8r9r:r;rr-r-r-r.rR{s $rRcr) LieDerivativea;Lie derivative with respect to a vector field. Explanation =========== The transport operator that defines the Lie derivative is the pushforward of the field to be derived along the integral curve of the field with respect to which one derives. Examples ======== >>> from sympy.diffgeom.rn import R2_r, R2_p >>> from sympy.diffgeom import (LieDerivative, TensorProduct) >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> e_rho, e_theta = R2_p.base_vectors() >>> dx, dy = R2_r.base_oneforms() >>> LieDerivative(e_x, fy) 0 >>> LieDerivative(e_x, fx) 1 >>> LieDerivative(e_x, e_x) 0 The Lie derivative of a tensor field by another tensor field is equal to their commutator: >>> LieDerivative(e_x, e_rho) Commutator(e_x, e_rho) >>> LieDerivative(e_x + e_y, fx) 1 >>> tp = TensorProduct(dx, dy) >>> LieDerivative(e_x, tp) LieDerivative(e_x, TensorProduct(dx, dy)) >>> LieDerivative(e_x, tp) LieDerivative(e_x, TensorProduct(dx, dy)) csjt|}t|dkst|rtd|dkr&t|||}||_||_|S|tr0t ||S| |S)Nr7zmLie derivatives are defined only with respect to vector fields. The supplied argument was not a vector field.r) rrrr"r#_v_field_exprrrrr>)r&v_fieldrd expr_form_ordr*r+r-r.r#s   zLieDerivative.__new__cCr/r0r1r3r-r-r.r`r5zLieDerivative.v_fieldcCr/r6r1r3r-r-r.rdr5zLieDerivative.exprcs@|j|j}|}tfddttD}||S)Ncs<g|]}td|t|f|ddqSr6)r rrJr2rqr-r.rNs4z*LieDerivative.__call__..)r`rdrr]r)r4r2rd lead_termrestr-rbr.rs  zLieDerivative.__call__) r8r9r:r;r#r<r`rdrr=r-r-r+r.r]s *  r]csLeZdZdZfddZeddZeddZedd Zd d Z Z S) BaseCovarDerivativeOpasCovariant derivative operator with respect to a base vector. Examples ======== >>> from sympy.diffgeom.rn import R2_r >>> from sympy.diffgeom import BaseCovarDerivativeOp >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct >>> TP = TensorProduct >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> dx, dy = R2_r.base_oneforms() >>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy)) >>> ch [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> cvd = BaseCovarDerivativeOp(R2_r, 0, ch) >>> cvd(fx) 1 >>> cvd(fx*e_x) e_x cs8t|}t|}t||||}||_||_||_|SrC)rrr"r#rr _christoffel)r&rr christoffelr*r+r-r.r#szBaseCovarDerivativeOp.__new__cCr/r0r1r3r-r-r.rr5zBaseCovarDerivativeOp.coord_syscCr/r6r1r3r-r-r.r r5zBaseCovarDerivativeOp.indexcCr/rr1r3r-r-r.rg$r5z!BaseCovarDerivativeOp.christoffelc s t|dkr tt|j}jjjjt|t }fddt |D}| tt ||}|}| tt ||}g}|D]t fddtjjD}||qKfdd|D}| tt ||}| tt ||}|S)zApply on a scalar field. The action of a vector field on a scalar field is a directional differentiation. If the argument is not a scalar field the behaviour is undefined. rcrrrr) wrt_scalarr-r.rN;r z2BaseCovarDerivativeOp.__call__..cs,g|]}j|jjfj|qSr-)rfrrrrKrp)r4rq wrt_vectorr-r.rNFs  cg|]}|qSr-r-rKd)rjr-r.rNJr[)rrvectors_in_basisrrrrrrrrxrrrr]r(r@r) r4fieldvectorsrrderivsrmto_subsrr-)r4rqrhrjr.r(s,     zBaseCovarDerivativeOp.__call__) r8r9r:r;r#r<rrrgrr=r-r-r+r.res    recr) CovarDerivativeOpaNCovariant derivative operator. Examples ======== >>> from sympy.diffgeom.rn import R2_r >>> from sympy.diffgeom import CovarDerivativeOp >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct >>> TP = TensorProduct >>> fx, fy = R2_r.base_scalars() >>> e_x, e_y = R2_r.base_vectors() >>> dx, dy = R2_r.base_oneforms() >>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy)) >>> ch [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> cvd = CovarDerivativeOp(fx*e_x, ch) >>> cvd(fx) x >>> cvd(fx*e_x) x*e_x csftdd|tDdkrtt|dkst|rtdt|}t |||}||_ ||_ |S)NcSrr-rr r-r-r.rnrz,CovarDerivativeOp.__new__..r7zsCovariant derivatives are defined only with respect to vector fields. The supplied argument was not a vector field.) rrrrrrrrr"r#_wrtrf)r&wrtrgr*r+r-r.r#mszCovarDerivativeOp.__new__cCr/r0r1r3r-r-r.ru{r5zCovarDerivativeOp.wrtcCr/r6r1r3r-r-r.rgr5zCovarDerivativeOp.christoffelcs>tjt}fdd|D}jtt|||S)Ncsg|] }t|j|jjqSr-)rerrrfr r3r-r.rNz.CovarDerivativeOp.__call__..)rrtrrrrr>)r4rorpbase_opsr-r3r.rs  zCovarDerivativeOp.__call__) r8r9r:r;r#r<rurgrr=r-r-r+r.rsTs   rsNFcstdks trtdfddfdd|r!|nj}|}fdd|D}|r>> from sympy.abc import t, x, y >>> from sympy.diffgeom.rn import R2_p, R2_r >>> from sympy.diffgeom import intcurve_series Specify a starting point and a vector field: >>> start_point = R2_r.point([x, y]) >>> vector_field = R2_r.e_x Calculate the series: >>> intcurve_series(vector_field, t, start_point, n=3) Matrix([ [t + x], [ y]]) Or get the elements of the expansion in a list: >>> series = intcurve_series(vector_field, t, start_point, n=3, coeffs=True) >>> series[0] Matrix([ [x], [y]]) >>> series[1] Matrix([ [t], [0]]) >>> series[2] Matrix([ [0], [0]]) The series in the polar coordinate system: >>> series = intcurve_series(vector_field, t, start_point, ... n=3, coord_sys=R2_p, coeffs=True) >>> series[0] Matrix([ [sqrt(x**2 + y**2)], [ atan2(y, x)]]) >>> series[1] Matrix([ [t*x/sqrt(x**2 + y**2)], [ -t*y/(x**2 + y**2)]]) >>> series[2] Matrix([ [t**2*(-x**2/(x**2 + y**2)**(3/2) + 1/sqrt(x**2 + y**2))/2], [ t**2*x*y/(x**2 + y**2)**2]]) See Also ======== intcurve_diffequ r7*The supplied field was not a vector field.cstddg||S)z=Return ``vector_field`` called `i` times on ``scalar_field``.cSrrCrL)rnrqr-r-r.rs z6intcurve_series..iter_vfield..r)rrL) vector_fieldr-r. iter_vfieldsz$intcurve_series..iter_vfieldcsfddtDS)z-Return the series for one of the coordinates.cs,g|]}||t|qSr-)r>rrJ)rr{param start_pointr-r.rN$zCintcurve_series..taylor_terms_per_coord..)r]r)r{rQr|r}rr.taylor_terms_per_coordsz/intcurve_series..taylor_terms_per_coordcrkr-r-r )rr-r.rNr[z#intcurve_series..cSrYr-)r{rr-r-r.rNr[cSrYr-rI)rKrAr-r-r.rNr[)rrrrrrr{)rzr|r}rQrcoeffsr taylor_termsr-)r{rQr|r}rrzr.intcurve_seriesse rcstdks trtd|r|nj}fddtjjD}t|||}fdd|D}fdd|D}||fS)a5Return the differential equation for an integral curve of the field. Explanation =========== Integral curve is a function `\gamma` taking a parameter in `R` to a point in the manifold. It verifies the equation: `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)` where the given ``vector_field`` is denoted as `V`. This holds for any value `t` for the parameter and any scalar field `f`. This function returns the differential equation of `\gamma(t)` in terms of the coordinate system ``coord_sys``. The equations and expansions are necessarily done in coordinate-system-dependent way as there is no other way to represent movement between points on the manifold (i.e. there is no such thing as a difference of points for a general manifold). Parameters ========== vector_field the vector field for which an integral curve will be given param the argument of the function `\gamma` from R to the curve start_point the point which corresponds to `\gamma(0)` coord_sys the coordinate system in which to give the equations Returns ======= a tuple of (equations, initial conditions) Examples ======== Use the predefined R2 manifold: >>> from sympy.abc import t >>> from sympy.diffgeom.rn import R2, R2_p, R2_r >>> from sympy.diffgeom import intcurve_diffequ Specify a starting point and a vector field: >>> start_point = R2_r.point([0, 1]) >>> vector_field = -R2.y*R2.e_x + R2.x*R2.e_y Get the equation: >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point) >>> equations [f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)] >>> init_cond [f_0(0), f_1(0) - 1] The series in the polar coordinate system: >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p) >>> equations [Derivative(f_0(t), t), Derivative(f_1(t), t) - 1] >>> init_cond [f_0(0) - 1, f_1(0) - pi/2] See Also ======== intcurve_series r7rycsg|] }td|qS)zf_%drrJ)r|r-r.rNUrRz$intcurve_diffequ..cs0g|]}tt||qSr-)rr r>rKcf) arbitrary_pr|rzr-r.rNYs(cs,g|]}t|d|qSr)rr>rr)rr|r}r-r.rN[r~)rrrrr]r(rr)rzr|r}rgammasr equations init_condr-)rr|r}rzr.intcurve_diffequsL  rcs>tdd|D}tt||tfdd|D}||fS)NcSrr-rrr-r-r.rNer[zdummyfy..csg|] }t|qSr-)rr)rKrdrepsr-r.rNgr')r{rr)r2rd_argsd_exprsr-rr.rcsrcCst|trdd|jD}tt|dkrtd|dSt|trCdd|jD}dd|D}t|dkr;td|s?dS|dSt|trXt|j sRt|j rVtd dSt|t r_dSt|t rnt d d |jDS|ru|trwdSd S) a`Return the contravariant order of an expression. Examples ======== >>> from sympy.diffgeom import contravariant_order >>> from sympy.diffgeom.rn import R2 >>> from sympy.abc import a >>> contravariant_order(a) 0 >>> contravariant_order(a*R2.x + 2) 0 >>> contravariant_order(a*R2.x*R2.e_y + R2.e_x) 1 cSrYr-rrr-r-r.rNr[z'contravariant_order..r7zFMisformed expression containing contravariant fields of varying order.rcSrYr-rrr-r-r.rNr[cSg|]}|dkr|qSrr-rTr-r-r.rNrXz?Misformed expression containing multiplication between vectors.z4Misformed expression containing a power of a vector.csrSrCrr;r-r-r.rvrz&contravariant_order..rz)r!rr2rrrr r rbaseexprrBrJrrrd_strictrKnot_zeror-r-r.rms0      rcCst|trdd|jD}tt|dkrtd|dSt|trCdd|jD}dd|D}t|dkr;td|s?dS|dSt|trXt|j sRt|j rVtd dSt|t rdt|jdSt|t rst d d |jDS|rz|tr|dSd S) aJReturn the covariant order of an expression. Examples ======== >>> from sympy.diffgeom import covariant_order >>> from sympy.diffgeom.rn import R2 >>> from sympy.abc import a >>> covariant_order(a) 0 >>> covariant_order(a*R2.x + 2) 0 >>> covariant_order(a*R2.x*R2.dy + R2.dx) 1 cSrYr-rrr-r-r.rNr[z#covariant_order..r7z=Misformed expression containing form fields of varying order.rcSrYr-rrr-r-r.rNr[cSrrr-rTr-r-r.rNrXz=Misformed expression containing multiplication between forms.z2Misformed expression containing a power of a form.csrSrCrr;r-r-r.rvrz"covariant_order..rz)r!rr2rrrr r rrrrrBrJrrrr-r-r.rs0      rcCsht|t}g}|D]}|j}|||}|jt||j }| |q | tt ||S)aTransform all base vectors in base vectors of a specified coord basis. While the new base vectors are in the new coordinate system basis, any coefficients are kept in the old system. Examples ======== >>> from sympy.diffgeom import vectors_in_basis >>> from sympy.diffgeom.rn import R2_r, R2_p >>> vectors_in_basis(R2_r.e_x, R2_p) -y*e_theta/(x**2 + y**2) + x*e_rho/sqrt(x**2 + y**2) >>> vectors_in_basis(R2_p.e_r, R2_r) sin(theta)*e_y + cos(theta)*e_x ) rrrrrrTr{rrr@rr)rdrrp new_vectorsrqcsrnewr-r-r.rns rncsltdks trtdt}t|dkrtd|}|fddD}t|S)aReturn the matrix representing the twoform. For the twoform `w` return the matrix `M` such that `M[i,j]=w(e_i, e_j)`, where `e_i` is the i-th base vector field for the coordinate system in which the expression of `w` is given. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import twoform_to_matrix, TensorProduct >>> TP = TensorProduct >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) Matrix([ [1, 0], [0, 1]]) >>> twoform_to_matrix(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) Matrix([ [x, 0], [0, 1]]) >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy) - TP(R2.dx, R2.dy)/2) Matrix([ [ 1, 0], [-1/2, 1]]) rwz'The input expression is not a two-form.r7zThe input expression concerns more than one coordinate systems, hence there is no unambiguous way to choose a coordinate system for the matrix.cs g|] fddDqS)csg|]}|qSr-rL)rKr&)rdr)r-r.rNrXz0twoform_to_matrix...r-rKrdrpr(r.rNsz%twoform_to_matrix..) rrrrrpoprr#r{)rdrmatrix_contentr-rr.twoform_to_matrixs  rcsdt|s tdt|}fdd|Dtt|jfddD}t |S)aXReturn the nested list of Christoffel symbols for the given metric. This returns the Christoffel symbol of first kind that represents the Levi-Civita connection for the given metric. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Christoffel_1st, TensorProduct >>> TP = TensorProduct >>> metric_to_Christoffel_1st(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> metric_to_Christoffel_1st(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[1/2, 0], [0, 0]], [[0, 0], [0, 0]]] z6The two-form representing the metric is not symmetric.crr-) applyfuncrl)matrixr-r.rN,rz-metric_to_Christoffel_1st..cs"g|] fddDqS)cs"g|] fddDqS)cs@g|]}|f|f|fdqS)rwr-ri)deriv_matricesrLr@r-r.rN.s8zCmetric_to_Christoffel_1st....r-r)rrLrPr@r.rN.  z8metric_to_Christoffel_1st...r-r)rrPrLr.rN.s  ) r is_symmetricrrrrrr]r(r)rdrrgr-)rrPrr.metric_to_Christoffel_1sts  rcst|t|}tt|jt|t}D] }|| t qt|}|j } tt || tt ||fddD}t|S)a]Return the nested list of Christoffel symbols for the given metric. This returns the Christoffel symbol of second kind that represents the Levi-Civita connection for the given metric. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct >>> TP = TensorProduct >>> metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> metric_to_Christoffel_2nd(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[1/(2*x), 0], [0, 0]], [[0, 0], [0, 0]]] cs$g|]fddDqS)cs&g|]fddDqS)cs*g|]tfddDqS)cs&g|]}|f|fqSr-r-rKl)ch_1strLr@rprr-r.rNUs&zNmetric_to_Christoffel_2nd.....rr)rrLrPr@rrpr.rNU"zCmetric_to_Christoffel_2nd....r-r)rrLrPrrr.rNU  z8metric_to_Christoffel_2nd...r-rrrPrrr.rNU  z-metric_to_Christoffel_2nd..)rrrrr]r(rrupdaterrrkrrinvr)rdrs_fieldsrdumsrgr-rr.metric_to_Christoffel_2nd5s (rcs~t|t|ttjfddDfddDfddDfddD}t|S)a!Return the components of the Riemann tensor expressed in a given basis. Given a metric it calculates the components of the Riemann tensor in the canonical basis of the coordinate system in which the metric expression is given. Examples ======== >>> from sympy import exp >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Riemann_components, TensorProduct >>> TP = TensorProduct >>> metric_to_Riemann_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]] >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + R2.r**2*TP(R2.dtheta, R2.dtheta) >>> non_trivial_metric exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta) >>> riemann = metric_to_Riemann_components(non_trivial_metric) >>> riemann[0, :, :, :] [[[0, 0], [0, 0]], [[0, exp(-2*rho)*rho], [-exp(-2*rho)*rho, 0]]] >>> riemann[1, :, :, :] [[[0, -1/rho], [1/rho, 0]], [[0, 0], [0, 0]]] cs$g|]fddDqS)cs$g|]fddDqS)cs(g|]fddDqS)csg|] }|fqSr-r-rl)ch_2ndrLr@rpr-r.rN{rvQmetric_to_Riemann_components.....)rr)rrrLr@rr.rN{s  Fmetric_to_Riemann_components....r-r)rrrLrPrr.rN{r;metric_to_Riemann_components...r-r)rrrPrr.rN{  z0metric_to_Riemann_components..c"g|] fddDqS)c$g|]fddDqS)cs$g|]fddDqS)cs4g|]}||qSr-r-rKnu)deriv_chmurhosigr-r.rN,rr-r)rrPrrrr.rNs  rr-r)rrPrrr.rNrrr-r)rrPrr.rN  cr)cr)cs&g|]fddDqS)cs*g|]tfddDqS)csDg|]}|f|f|f|fqSr-r-r)rrrrrr-r.rNsDz\metric_to_Riemann_components......rr)rrPrrr)rr.rNrrr-r)rrPrrrr.rNrrr-r)rrPrrr.rNrrr-r)rrPrr.rNrcs$g|]fddDqS)cs&g|]fddDqS)cs&g|]fddDqS)cs4g|]}||qSr-r-r)rr riemann_a riemann_brr-r.rNrrr-r)rPrrrrrr.rNrrr-r)rPrrrrr.rNs  rr-r)rPrrrr.rNr)rrrrr]r(r)rdriemannr-)rrrrPrrr.metric_to_Riemann_components\s    rcs>t|t|}tt|jfddD}t|S)a]Return the components of the Ricci tensor expressed in a given basis. Given a metric it calculates the components of the Ricci tensor in the canonical basis of the coordinate system in which the metric expression is given. Examples ======== >>> from sympy import exp >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Ricci_components, TensorProduct >>> TP = TensorProduct >>> metric_to_Ricci_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[0, 0], [0, 0]] >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + R2.r**2*TP(R2.dtheta, R2.dtheta) >>> non_trivial_metric exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta) >>> metric_to_Ricci_components(non_trivial_metric) [[1/rho, 0], [0, exp(-2*rho)*rho]] cs"g|] fddDqS)cs&g|]tfddDqS)csg|] }||fqSr-r-ri)rLr@rr-r.rNrRzDmetric_to_Ricci_components....rr)rLrPrrr.rNsz9metric_to_Ricci_components...r-rrPrrr.rNrz.metric_to_Ricci_components..)rrrrr]r(r)rdrriccir-rr.metric_to_Ricci_componentss  rcsHeZdZfddZddZfddZfddZfd d ZZS) _deprecated_containercst|||_dSrC)r"__init__message)r4rdatar+r-r.rs  z_deprecated_container.__init__cCst|jdddddS)NrSrT)rVrW stacklevel)rrr3r-r-r.warns  z_deprecated_container.warncs|tSrC)rr"__iter__r3r+r-r.rs z_deprecated_container.__iter__c|t|SrC)rr" __getitem__r4rtr+r-r.r z!_deprecated_container.__getitem__crrC)rr" __contains__rr+r-r.rrz"_deprecated_container.__contains__) r8r9r:rrrrrr=r-r-r+r.rs    rc@ eZdZdS)r$Nr8r9r:r-r-r-r.r$r$c@r)reNrr-r-r-r.rerre)r)rxNFrC)F)L __future__rtypingr functoolsr itertoolsrsympy.combinatoricsr sympy.corerr r r r r rrrrrsympy.core.cachersympy.core.symbolrrrsympy.core.sympifyrsympy.functionsrsympy.matricesrr{ sympy.solversrsympy.utilities.exceptionsrrrsympy.tensor.arrayrr r>rFrurrrrrrrBrRr]rersrrrrrrnrrrrrrrr$rresympy.simplify.simplifyrr-r-r-r.sb    4       <FANSe|NnW1M[ 9 y] .1+ '6&