DGCV 0.2.3__tar.gz → 0.2.4__tar.gz

dgcv-0.2.4/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: DGCV
+Version: 0.2.4
+Summary: Differential Geometry with Complex Variables
+Author: David Sykes
+Author-email: David Sykes <david@realandimaginary.com>
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: sympy>=1.9
+Requires-Dist: pandas>=1.0
+Requires-Dist: ipython>=7.0
+
+# DGCV: Differential Geometry with Complex Variables
+
+DGCV is an open-source Python package providing basic tools for differential geometry integrated with systematic organization of structures accompanying complex variables, in short, Differential Geometry with Complex Variables.
+
+At its core are fully featured symbolic representations of standard DG objects such as vector fields and differential forms, defined relative to standard or complex coordinate systems. As systems of differential geometric objects constructed from complex variables inherit natural relationships from the underlying complex structure, DGCV tracks these relationships across the constructions. Immediate advantages of the uniform integration are seen in smooth switching between real and holomorphic coordinate representations of mathematical objects. In computations, DGCV classes dynamically manage this format switching on their own so that typical complex variables formulas can be written plainly and will simply work. Some examples of this: In coordinates $z_j = x_j + iy_j$, expressions such as $\frac{\partial}{\partial x_j}|z_j|^2$ or $d z_j \wedge d \overline{z_j} \left( \frac{\partial}{\partial z_j}, \frac{\partial}{\partial y_j} \right)$ are correctly parsed without needing to convert everything to a uniform variable format. Retrieving objects' complex structure-related attributes, like the holomorphic part of a vector field or pluriharmonic terms from a polynomial is straightforward. Complexified cotangent bundles and their exterior algebras are easily decomposed into components from the Dolbeault complex and Dolbeault operators themselves can be applied to functions and k-forms in either coordinate format.
+
+DGCV was developed using Python 3.12, with dependencies on the SymPy and Pandas libraries in addition to base Python. Its classes integrate SymPy objects within their data structures and subclass from SymPy.Basic, thereby inheriting much of SymPy’s functionality. For instance, one can apply sympy.simplify() directly to most DGCV class objects. Developing complete compatibility with SymPy is a goal still in progress. Pandas is used to format and display data in a more readable manner.
+
+## Features
+- Fully featured symbolic representations of vector fields, differential forms, and tensor fields
+- Intuitive interactions with complex structures from holomorphic coordinate systems: DGCV objects dynamically manage coordinate transformations between real and holomorphic coordinates during computation as necessary, so objects can be represented in and freely converted between either coordinate format at any time. 
+- Dedicated python classes for representing common differential geometric structures including Riemannian metrics, Kahler structures, and more
+- Custom LaTeX rendering for clean visual representation of mathematical objects, ideal for sharing mathematical ideas through clear Jupyter notebooks.
+
+## Installation
+
+You can install DGCV directly from PyPI with pip:
+
+```bash
+pip install DGCV
+```
+
+Note, depending on the operating system, a command like `python3` (for macOS/ Linux) or `py` (for windows) should proceed `pip`.
+
+## Tutorials
+
+Two Jupyter Notebook tutorials are available to help getting started with DGCV:
+
+1. **DGCV Introduction**: An introduction to the key concepts and setup
+   - [View DGCV Introduction Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_introduction/)
+
+2. **DGCV in Action**: A quick tour through examples from some of the library's more elaborate functions
+   - [View DGCV in Action Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_in_action/)
+
+
+### Running the Tutorials Locally
+
+If you clone the DGCV github repository, you can run the tutorials locally with Jupyter:
+
+```bash
+git clone https://github.com/YikesItsSykes/DGCV.git
+cd DGCV/tutorials
+jupyter notebook DGCV_introduction.ipynb
+jupyter notebook DGCV_in_action.ipynb
+```
+Or download the tutorials individually from the repository [DGCV github repo](https://github.com/YikesItsSykes/DGCV).
+
+## Documentation
+DGCV documentation is hosted at [https://www.realandimaginary.com/dgcv/](https://www.realandimaginary.com/dgcv/), with documentation pages for each function in the library and more. Full documentation is under development, so for now, refer to the docstrings within the code for more information on available classes/methods and functions.
+
+## License
+DGCV is licensed under the MIT License. See the `LICENSE.txt` file for more information.
+
+## Author
+DGCV was created and is maintained by [David Sykes](https://www.realandimaginary.com).
+
+---
+
+### Future Development
+The current (0.x.x) version of DGCV is foundation on which a lot more can be built. Many additions for future updates are planned, including:
+ - Extending complex variable handling and dynamic coordinate-type conversion automations. The simple goal is to fully automate handling of complex variable formats, allowing input to be formatted freely with any coordinate type, with features to fully control coordinate type formatting or let the sytems automate the process. The current API meets this goal for interactions with DGCV's core classes, but it is not fully extended to some ancillary classes. For example, full coordinate conversion features are implemented for differential forms but not yet for general tensor fields.
+ - Expanding libraries dedicated to specialized areas of differential geometry including, Symplect/Contact Hamiltonian formalism, CR structures, Riemannian and Kahler, Sasakian, etc.
+
+Contributions and feedback from anyone interested are warmly welcomed.
+Stay tuned for more updates!

dgcv-0.2.4/README.md

@@ -0,0 +1,65 @@
+# DGCV: Differential Geometry with Complex Variables
+
+DGCV is an open-source Python package providing basic tools for differential geometry integrated with systematic organization of structures accompanying complex variables, in short, Differential Geometry with Complex Variables.
+
+At its core are fully featured symbolic representations of standard DG objects such as vector fields and differential forms, defined relative to standard or complex coordinate systems. As systems of differential geometric objects constructed from complex variables inherit natural relationships from the underlying complex structure, DGCV tracks these relationships across the constructions. Immediate advantages of the uniform integration are seen in smooth switching between real and holomorphic coordinate representations of mathematical objects. In computations, DGCV classes dynamically manage this format switching on their own so that typical complex variables formulas can be written plainly and will simply work. Some examples of this: In coordinates $z_j = x_j + iy_j$, expressions such as $\frac{\partial}{\partial x_j}|z_j|^2$ or $d z_j \wedge d \overline{z_j} \left( \frac{\partial}{\partial z_j}, \frac{\partial}{\partial y_j} \right)$ are correctly parsed without needing to convert everything to a uniform variable format. Retrieving objects' complex structure-related attributes, like the holomorphic part of a vector field or pluriharmonic terms from a polynomial is straightforward. Complexified cotangent bundles and their exterior algebras are easily decomposed into components from the Dolbeault complex and Dolbeault operators themselves can be applied to functions and k-forms in either coordinate format.
+
+DGCV was developed using Python 3.12, with dependencies on the SymPy and Pandas libraries in addition to base Python. Its classes integrate SymPy objects within their data structures and subclass from SymPy.Basic, thereby inheriting much of SymPy’s functionality. For instance, one can apply sympy.simplify() directly to most DGCV class objects. Developing complete compatibility with SymPy is a goal still in progress. Pandas is used to format and display data in a more readable manner.
+
+## Features
+- Fully featured symbolic representations of vector fields, differential forms, and tensor fields
+- Intuitive interactions with complex structures from holomorphic coordinate systems: DGCV objects dynamically manage coordinate transformations between real and holomorphic coordinates during computation as necessary, so objects can be represented in and freely converted between either coordinate format at any time. 
+- Dedicated python classes for representing common differential geometric structures including Riemannian metrics, Kahler structures, and more
+- Custom LaTeX rendering for clean visual representation of mathematical objects, ideal for sharing mathematical ideas through clear Jupyter notebooks.
+
+## Installation
+
+You can install DGCV directly from PyPI with pip:
+
+```bash
+pip install DGCV
+```
+
+Note, depending on the operating system, a command like `python3` (for macOS/ Linux) or `py` (for windows) should proceed `pip`.
+
+## Tutorials
+
+Two Jupyter Notebook tutorials are available to help getting started with DGCV:
+
+1. **DGCV Introduction**: An introduction to the key concepts and setup
+   - [View DGCV Introduction Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_introduction/)
+
+2. **DGCV in Action**: A quick tour through examples from some of the library's more elaborate functions
+   - [View DGCV in Action Tutorial](https://www.realandimaginary.com/dgcv/tutorials/DGCV_in_action/)
+
+
+### Running the Tutorials Locally
+
+If you clone the DGCV github repository, you can run the tutorials locally with Jupyter:
+
+```bash
+git clone https://github.com/YikesItsSykes/DGCV.git
+cd DGCV/tutorials
+jupyter notebook DGCV_introduction.ipynb
+jupyter notebook DGCV_in_action.ipynb
+```
+Or download the tutorials individually from the repository [DGCV github repo](https://github.com/YikesItsSykes/DGCV).
+
+## Documentation
+DGCV documentation is hosted at [https://www.realandimaginary.com/dgcv/](https://www.realandimaginary.com/dgcv/), with documentation pages for each function in the library and more. Full documentation is under development, so for now, refer to the docstrings within the code for more information on available classes/methods and functions.
+
+## License
+DGCV is licensed under the MIT License. See the `LICENSE.txt` file for more information.
+
+## Author
+DGCV was created and is maintained by [David Sykes](https://www.realandimaginary.com).
+
+---
+
+### Future Development
+The current (0.x.x) version of DGCV is foundation on which a lot more can be built. Many additions for future updates are planned, including:
+ - Extending complex variable handling and dynamic coordinate-type conversion automations. The simple goal is to fully automate handling of complex variable formats, allowing input to be formatted freely with any coordinate type, with features to fully control coordinate type formatting or let the sytems automate the process. The current API meets this goal for interactions with DGCV's core classes, but it is not fully extended to some ancillary classes. For example, full coordinate conversion features are implemented for differential forms but not yet for general tensor fields.
+ - Expanding libraries dedicated to specialized areas of differential geometry including, Symplect/Contact Hamiltonian formalism, CR structures, Riemannian and Kahler, Sasakian, etc.
+
+Contributions and feedback from anyone interested are warmly welcomed.
+Stay tuned for more updates!

dgcv-0.2.4/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+requires-python = ">=3.6"
+name = "DGCV"
+version = "0.2.4"
+description = "Differential Geometry with Complex Variables"
+authors = [{ name = "David Sykes", email = "david@realandimaginary.com" }]
+license = { text = "MIT" }
+dependencies = ["sympy>=1.9", "pandas>=1.0", "ipython>=7.0"]
+readme = "README.md"
+
+[tool.ruff]
+line-length = 88
+select = ["F", "E", "W", "I"]
+extend-exclude = ["_build", "buck-out", "build", "dist", "tutorials"]
+
+[tool.ruff.lint]
+ignore = ["E501", "Q", "W291"]
+
+[tool.black]
+line-length = 88
+skip-string-normalization = false
+target-version = ["py37", "py38", "py39", "py310", "py311"]

{dgcv-0.2.3 → dgcv-0.2.4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = DGCV
-version = 0.2.3
+version = 0.2.4
 description = A package for Differential Geometry with Complex Variables
 author = David Sykes
 author_email = david@realandimaginary.com

{dgcv-0.2.3 → dgcv-0.2.4}/setup.py

@@ -1,4 +1,4 @@
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
 long_description = """
 # DGCV - Differential Geometry with Complex Variables
@@ -15,7 +15,7 @@ To get started, check out the Jupyter Notebook tutorials:
 
 setup(
     name="DGCV",
-    version="0.2.3",
+    version="0.2.4",
     description="Differential Geometry with Complex Variables",
     long_description=long_description,  # This shows up on PyPI
     long_description_content_type="text/markdown",

{dgcv-0.2.3 → dgcv-0.2.4}/src/DGCV/CRGeometry.py

@@ -24,15 +24,41 @@ License:
 """
 
 ############## dependencies
-from sympy import eye, expand, Matrix, numer, poly_from_expr, solve, Transpose, Symbol
 from functools import reduce
-from .config import _cached_caller_globals
-from .combinatorics import *
-from .DGCore import *
-from .vectorFieldsAndDifferentialForms import *
-from .polynomials import *
-from ._safeguards import retrieve_passkey
 
+from sympy import (
+    I,
+    Matrix,
+    Rational,
+    Symbol,
+    Transpose,
+    conjugate,
+    expand,
+    eye,
+    im,
+    numer,
+    poly_from_expr,
+    simplify,
+    solve,
+)
+
+from ._safeguards import retrieve_passkey
+from .config import _cached_caller_globals
+from .DGCVCore import (
+    VFClass,
+    addVF,
+    allToReal,
+    clearVar,
+    holToReal,
+    holVF_coeffs,
+    listVar,
+    realPartOfVF,
+    scaleVF,
+    symToReal,
+    variableProcedure,
+)
+from .polynomials import createPolynomial
+from .vectorFieldsAndDifferentialForms import assembleFromHolVFC
 
 ############## CR geometry
 
@@ -213,12 +239,12 @@ def findWeightedCRSymmetries(
     varLoc1.difference_update(varLoc)
     varComp.difference_update(varLoc1)
     variableProcedure(arg6, len(varLoc), assumeReal=True)
-    if applyNumer == True:
+    if applyNumer:
         if varLoc1 == set():
             varLoc1 = set(arg2)
         coefListLoc = poly_from_expr(expand(numer(tOLoc)), *varLoc1)[0].coeffs()
         solLoc = solve(coefListLoc, varLoc)
-    elif simplifyingFactor == None:
+    elif simplifyingFactor is None:
         if varLoc1 == set():
             varLoc1 = set(arg2)
         coefListLoc = poly_from_expr(expand(tOLoc), *varLoc1)[0].coeffs()
@@ -233,7 +259,7 @@ def findWeightedCRSymmetries(
     if solLoc == []:
         clearVar(*listVar(temporary_only=True), report=False)
         return "no solution"
-    elif type(solLoc) == dict:
+    elif type(solLoc) is dict:
         VFCLoc = [j.subs(solLoc) for j in holVF_coeffs(VFLoc, arg2)]
         subVar = sum(VFCLoc).atoms(Symbol)
         subVar.difference_update(set(arg2))
@@ -243,12 +269,12 @@ def findWeightedCRSymmetries(
             for j in VFCLoc
         ]
         clearVar(*listVar(temporary_only=True), report=False)
-        if returnVectorFieldBasis == True:
+        if returnVectorFieldBasis:
             VFListLoc = []
             for j in eval(arg6, _cached_caller_globals):
                 VFCLocTemp = [
                     k.subs(j, 1).subs(
-                        [(l, 0) for l in eval(arg6, _cached_caller_globals)]
+                        [(ll, 0) for ll in eval(arg6, _cached_caller_globals)]
                     )
                     for k in VFCLoc
                 ]
@@ -306,7 +332,7 @@ def model2Nondegenerate(arg1, arg2, arg3, arg4, return_matrices=False):
         * arg2
         * arg1
     )
-    if return_matrices == True:
+    if return_matrices:
         return (
             simplify(
                 (