gfold 0.1.0__py3-none-any.whl

gfold/__init__.py

@@ -0,0 +1,6 @@
+"""G-FOLD: Fuel Optimal Large Divert Guidance Algorithm."""
+
+from .solver import GFoldSolver
+from .config import GFoldConfig
+
+__version__ = "0.1.0"

gfold/cli.py

@@ -0,0 +1,49 @@
+import argparse
+import os
+
+from .config import GFoldConfig
+from .solver import GFoldSolver
+from .visualization import plot_results
+
+def main():
+    """Command-line interface for the G-FOLD solver."""
+    parser = argparse.ArgumentParser(description="G-FOLD: Fuel Optimal Large Divert Guidance Algorithm")
+    parser.add_argument('-n', type=int, 
+                        help="Determines the amount of steps and thus determines dt (dt = tf/N)", 
+                        default=100)
+    parser.add_argument('-g', '--generate', 
+                        help="Generate C++/Python code to solve problems faster", 
+                        action="store_true")
+    parser.add_argument('-o', '--output', 
+                        help="Output directory for generated code or plot", 
+                        default=".")
+    parser.add_argument('--no-plot', 
+                        help="Don't display the plot", 
+                        action="store_true")
+    parser.add_argument('-s', '--save-plot', 
+                        help="Save the plot to a file (default: don't save)", 
+                        action="store_true")
+    
+    args = parser.parse_args()
+    
+    # Initialize solver
+    solver = GFoldSolver(GFoldConfig(n=args.n))
+    
+    # Generate code if requested
+    if args.generate:
+        output_dir = os.path.join(args.output, "code")
+        code_dir = solver.generate_code(code_dir=output_dir)
+        print(f"Generated code in {code_dir}")
+        return
+    
+    # Otherwise solve and visualize
+    print("Solving G-FOLD optimization problem...")
+    solution = solver.solve(verbose=True)
+    print(f"Final mass: {solution['final_mass']:.2f} kg")
+    
+    # Plot results
+    save_path = os.path.join(args.output, "gfold_plot.png") if args.save_plot else None
+    plot_results(solution, save_path=save_path, show=not args.no_plot)
+
+if __name__ == "__main__":
+    main()

gfold/config.py

@@ -0,0 +1,235 @@
+import numpy as np
+
+class SpacecraftConfig:
+    """Configuration for spacecraft parameters."""
+    
+    def __init__(self, **kwargs):
+        """
+        Initialize spacecraft configuration with default values.
+        
+        Args:
+            **kwargs: Any parameter can be overridden during initialization
+        """
+        # Mass parameters
+        self.wet_mass = 2000  # wet mass of the rocket (kg)
+        self.fuel = 1700  # weight of fuel (kg)
+        
+        # Thrust parameters
+        self.real_max_thrust = 24000  # maximum possible thrust (N)
+        self.min_thrust_pct = 0.2  # percentage of max thrust for minimum
+        self.max_thrust_pct = 0.8  # percentage of max thrust for maximum
+        
+        # Motion constraints
+        self.max_velocity = 1000  # maximum velocity (m/s)
+        
+        # Initial conditions
+        self.initial_position = [450, -330, 2400]  # (m)
+        self.initial_velocity = [-40, 10, -10]  # (m/s)
+        self.target_velocity = [0, 0, 0]  # (m/s)
+        self.target_position = [0, 0, 0]  # (m)
+        
+        # Physics parameters
+        self.fuel_consumption = 5e-4  # fuel consumption rate (kg/N/s)
+        
+        self._update_from_kwargs(kwargs)
+    
+    def _update_from_kwargs(self, kwargs):
+        """Update attributes from keyword arguments."""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                raise ValueError(f"Unknown spacecraft parameter: {key}")
+    
+    @property
+    def log_wet_mass(self):
+        """Natural logarithm of wet mass."""
+        return np.log(self.wet_mass)
+    
+    @property
+    def log_dry_mass(self):
+        """Natural logarithm of dry mass."""
+        return np.log(self.wet_mass - self.fuel)
+    
+    @property
+    def min_thrust(self):
+        """Minimum thrust value."""
+        return self.real_max_thrust * self.min_thrust_pct
+    
+    @property
+    def max_thrust(self):
+        """Maximum thrust value."""
+        return self.real_max_thrust * self.max_thrust_pct
+    
+    def to_dict(self):
+        """Convert configuration to dictionary."""
+        return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
+
+
+class EnvironmentConfig:
+    """Configuration for environment parameters."""
+    
+    def __init__(self, **kwargs):
+        """
+        Initialize environment configuration with default Mars values.
+        
+        Args:
+            **kwargs: Any parameter can be overridden during initialization
+        """
+        # Gravitational parameters
+        self.gravity = [0, 0, -3.71]  # gravity vector (m/s²), default is Mars
+        
+        # Landing constraints
+        self.glide_slope_angle = 0  # in degrees
+        self.max_angle = 90  # maximum angle for approach (degrees)
+        
+        self._update_from_kwargs(kwargs)
+    
+    def _update_from_kwargs(self, kwargs):
+        """Update attributes from keyword arguments."""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                raise ValueError(f"Unknown environment parameter: {key}")
+    
+    @property
+    def sin_glide_slope(self):
+        """Sine of the glide slope angle."""
+        return np.sin(np.radians(self.glide_slope_angle))
+    
+    @property
+    def cos_max_angle(self):
+        """Cosine of the maximum angle."""
+        return np.cos(np.radians(self.max_angle))
+    
+    @classmethod
+    def mars(cls):
+        """Create Mars environment configuration."""
+        return cls()
+    
+    @classmethod
+    def moon(cls):
+        """Create Moon environment configuration."""
+        return cls(gravity=[0, 0, -1.62])
+    
+    @classmethod
+    def earth(cls):
+        """Create Earth environment configuration."""
+        return cls(gravity=[0, 0, -9.81])
+    
+    def to_dict(self):
+        """Convert configuration to dictionary."""
+        return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
+
+
+class SolverConfig:
+    """Configuration for solver parameters."""
+    
+    def __init__(self, **kwargs):
+        """
+        Initialize solver configuration with default values.
+        
+        Args:
+            **kwargs: Any parameter can be overridden during initialization
+        """
+        # Solver parameters
+        self.n = 100  # number of discrete timesteps
+        self.time_of_flight = 44.63  # pre-calculated time of flight (s)
+        
+        self._update_from_kwargs(kwargs)
+    
+    def _update_from_kwargs(self, kwargs):
+        """Update attributes from keyword arguments."""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                raise ValueError(f"Unknown solver parameter: {key}")
+    
+    def to_dict(self):
+        """Convert configuration to dictionary."""
+        return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
+
+
+class GFoldConfig:
+    """Main configuration class for G-FOLD solver parameters."""
+    
+    def __init__(self, spacecraft=None, environment=None, solver=None, **kwargs):
+        """
+        Initialize configuration with default values that can be overridden.
+        
+        Args:
+            spacecraft (SpacecraftConfig): Spacecraft configuration
+            environment (EnvironmentConfig): Environment configuration
+            solver (SolverConfig): Solver configuration
+            **kwargs: Any parameter can be overridden during initialization
+        """
+        # Initialize sub-configurations
+        self.spacecraft = spacecraft if spacecraft is not None else SpacecraftConfig()
+        self.environment = environment if environment is not None else EnvironmentConfig.mars()
+        self.solver = solver if solver is not None else SolverConfig()
+        
+        # Process any remaining kwargs by trying to assign them to the appropriate sub-config
+        self._process_kwargs(kwargs)
+    
+    def _process_kwargs(self, kwargs):
+        """Process keyword arguments and assign to appropriate sub-config."""
+        for key, value in kwargs.items():
+            assigned = False
+            
+            for config_name in ['spacecraft', 'environment', 'solver']:
+                config = getattr(self, config_name)
+                print(config.to_dict())
+                if hasattr(config, key):
+                    setattr(config, key, value)
+                    assigned = True
+                    break
+            
+            if not assigned:
+                raise ValueError(f"Unknown configuration parameter: {key}")
+    
+    # Properties to maintain backward compatibility
+    @property
+    def log_wet_mass(self):
+        return self.spacecraft.log_wet_mass
+    
+    @property
+    def log_dry_mass(self):
+        return self.spacecraft.log_dry_mass
+    
+    @property
+    def sin_glide_slope(self):
+        return self.environment.sin_glide_slope
+    
+    @property
+    def cos_max_angle(self):
+        return self.environment.cos_max_angle
+    
+    @property
+    def min_thrust(self):
+        return self.spacecraft.min_thrust
+    
+    @property
+    def max_thrust(self):
+        return self.spacecraft.max_thrust
+    
+    @property
+    def time_of_flight(self):
+        return self.solver.time_of_flight
+    
+    @property
+    def wet_mass(self):
+        return self.spacecraft.wet_mass
+    
+    @property
+    def real_max_thrust(self):
+        return self.spacecraft.real_max_thrust
+    
+    def to_dict(self):
+        """Convert all configuration to a flat dictionary."""
+        result = {}
+        for config_name in ['spacecraft', 'environment', 'solver']:
+            config = getattr(self, config_name)
+            result.update(config.to_dict())
+        return result

gfold/solver.py

@@ -0,0 +1,242 @@
+import cvxpy as cp
+import numpy as np
+import os
+from cvxpygen import cpg
+from .config import GFoldConfig
+
+class GFoldSolver:
+    """
+    G-FOLD solver that implements the Fuel Optimal Large Divert Guidance Algorithm.
+    """
+    
+    def __init__(self, config=None):
+        """
+        Initialize the G-FOLD solver.
+        
+        Args:
+            config (GFoldConfig): Configuration object with problem parameters
+        """
+        self.config = config if config is not None else GFoldConfig()
+            
+        self.parameters = {}
+        self.variables = {}
+        self.constraints = []
+        self.problem = None
+        self._setup_problem()
+        
+    def _calculate_parameter(self, expression, *args, **kwargs):
+        """Helper function to create parameters from expressions with values"""
+        return cp.Parameter(*args, value=expression.value, **kwargs)
+
+    def _setup_problem(self):
+        """Set up the G-FOLD optimization problem."""
+        config = self.config
+        n = config.solver.n
+        t = config.solver.time_of_flight
+        
+        # Variables
+        x = cp.Variable((n, 6), "x")  # position(3), speed(3)
+        u = cp.Variable((n, 3), "u")  # acc due to rocket engine
+        s = cp.Variable(n, "s")  # slack variable, equal to |u|
+        z = cp.Variable(n, "z")  # ln(mass)
+        
+        self.variables = {
+            "x": x,
+            "u": u,
+            "s": s,
+            "z": z
+        }
+        
+        # Parameters
+        log_mass = cp.Parameter(name="log_mass", value=config.spacecraft.log_wet_mass)
+        max_vel = cp.Parameter(name="max_vel", value=config.spacecraft.max_velocity)
+        sin_glide_slope = cp.Parameter(name="sin_glide_slope", nonneg=True, value=config.environment.sin_glide_slope)
+        log_dry_mass = cp.Parameter(name="log_dry_mass", value=config.spacecraft.log_dry_mass)
+        min_t = cp.Parameter(nonneg=True, name="min_thrust", value=config.spacecraft.min_thrust)
+        max_t = cp.Parameter(nonneg=True, name="max_thrust", value=config.spacecraft.max_thrust)
+        dt = cp.Parameter(name="dt", value=t/n)
+        a = cp.Parameter(name="fuel_consumption", value=config.spacecraft.fuel_consumption)
+        a_dt = self._calculate_parameter(a*dt, name="fuel_consumption_dt")
+        
+        # Derived parameters
+        z0 = cp.Parameter(n, name="z0")
+        exp_z0 = cp.Parameter(n, name="exp_z0", nonneg=True)
+        max_exp = cp.Parameter(n, name="max_exp_z0", nonneg=True)
+        min_exp = cp.Parameter(n, name="min_exp_z0", nonneg=True)
+        
+        # Calculate values
+        c_z0 = []
+        c_exp_z0 = []
+        c_max_exp = []
+        c_min_exp = []
+
+        for i in range(n):
+            z00 = np.log(config.spacecraft.wet_mass - a.value*dt.value*max_t.value*i)
+            c_z0.append(z00)
+            c_exp_z0.append(np.exp(-z00))
+            c_max_exp.append(1/(np.exp(-z00) * max_t.value))
+            if min_t.value != 0:
+                c_min_exp.append(1/(np.exp(-z00) * min_t.value))
+
+        z0.value = c_z0
+        exp_z0.value = c_exp_z0
+        max_exp.value = c_max_exp
+        min_exp.value = c_min_exp
+
+        # More parameters
+        max_angle = cp.Parameter(name="max_angle", value=config.environment.cos_max_angle)
+        dt_squared = self._calculate_parameter(dt**2, name="dt_squared")
+        initial_pos = cp.Parameter(3, name="initial_position", value=config.spacecraft.initial_position)
+        initial_vel = cp.Parameter(3, name="initial_vel", value=config.spacecraft.initial_velocity)
+        target_vel = cp.Parameter(3, name="target_velocity", value=config.spacecraft.target_velocity)
+        g = cp.Parameter(3, name="gravity", value=config.environment.gravity)
+        g_dt = self._calculate_parameter(g*dt, 3, name="gravity_dt")
+        g_dt_sq = self._calculate_parameter(g*dt*dt, 3, name="gravity_dt_squared")
+        
+        # Store parameters
+        self.parameters = {
+            "log_mass": log_mass,
+            "max_vel": max_vel,
+            "sin_glide_slope": sin_glide_slope,
+            "log_dry_mass": log_dry_mass,
+            "min_thrust": min_t,
+            "max_thrust": max_t,
+            "dt": dt,
+            "fuel_consumption": a,
+            "fuel_consumption_dt": a_dt,
+            "z0": z0,
+            "exp_z0": exp_z0,
+            "max_exp_z0": max_exp,
+            "min_exp_z0": min_exp,
+            "max_angle": max_angle,
+            "dt_squared": dt_squared,
+            "initial_position": initial_pos,
+            "initial_vel": initial_vel,
+            "target_velocity": target_vel,
+            "gravity": g,
+            "gravity_dt": g_dt,
+            "gravity_dt_squared": g_dt_sq,
+        }
+        
+        # Constraints
+        constraints = [
+            x[0, :3] == initial_pos,
+            x[0, 3:] == initial_vel,
+            z[0] == log_mass,
+        ]
+
+        # Timestep constraints
+        for i in range(n):
+            constraints.append(cp.norm(x[i, 3:]) <= max_vel)  # never exceed the maximum velocity
+            constraints.append(x[i, 2] >= cp.norm(x[i, :3]) * sin_glide_slope)  # glide slope constraint
+            constraints.append(s[i] >= cp.norm(u[i, :]))  # |u| = s
+            constraints.append((1 - (z[i]-z0[i]) + cp.square(z[i]-z0[i])/2) <= s[i] * min_exp[i])
+            constraints.append(s[i] * max_exp[i] <= (1 - (z[i]-z0[i])))  # upper bound for s 
+            if i != n - 1:
+                acc = (u[i+1, :] + u[i, :])/2
+                constraints += [
+                    x[i+1, :3] == x[i, :3] + (x[i, 3:] + x[i+1, 3:]) * dt / 2 + (acc*dt_squared+g_dt_sq) * (1/2),  # position update
+                    x[i+1, 3:] == x[i, 3:] + acc*dt + g_dt,  # velocity update
+                    z[i+1] == z[i] - (s[i] + s[i+1]) / 2 * a_dt  # mass update
+                ]
+
+        # Constraints on the last step
+        constraints += [
+            x[n-1, :3] == config.spacecraft.target_position,  # landing site
+            x[n-1, 3:] == target_vel,
+            z[n-1] >= log_dry_mass,
+        ]
+        
+        self.constraints = constraints
+        
+        # Objective: maximize final mass
+        obj = cp.Maximize(z[n-1])
+        self.problem = cp.Problem(obj, constraints)
+        
+    def solve(self, verbose=False):
+        """
+        Solve the G-FOLD optimization problem.
+        
+        Args:
+            verbose (bool): Whether to print verbose output
+            
+        Returns:
+            dict: Solution containing positions, velocities, thrusts, and other data
+        """
+        if not self.problem:
+            raise ValueError("Problem not initialized properly")
+            
+        solution_val = self.problem.solve(verbose=verbose)
+        
+        # Extract solution data
+        x_val = self.variables["x"].value
+        u_val = self.variables["u"].value
+        z_val = self.variables["z"].value
+        s_val = self.variables["s"].value
+        
+        positions = x_val[:, :3]
+        velocities = x_val[:, 3:]
+        thrusts = np.array([np.linalg.norm(u) for u in u_val])
+        
+        # Adjust thrust for mass
+        for i in range(self.config.solver.n):
+            thrusts[i] *= np.exp(z_val[i])
+        
+        return {
+            "solution_value": solution_val,
+            "positions": positions,
+            "velocities": velocities,
+            "thrusts": thrusts,
+            "normalized_thrusts": thrusts / self.config.spacecraft.real_max_thrust,
+            "final_mass": np.exp(z_val[-1]),
+            "z_values": z_val,
+            "x_values": x_val,
+            "u_values": u_val,
+            "s_values": s_val,
+            "time_points": np.arange(0, self.parameters["dt"].value * self.config.solver.n, self.parameters["dt"].value)
+        }
+        
+    def generate_code(self, code_dir="code"):
+        """
+        Generate C++/Python code for the solver using cvxpygen.
+        
+        Args:
+            code_dir (str): Directory to save the generated code
+            
+        Returns:
+            str: Path to the generated code
+        """
+        if not self.problem:
+            raise ValueError("Problem not initialized properly")
+            
+        # Create directory if it doesn't exist
+        os.makedirs(code_dir, exist_ok=True)
+        
+        # Generate code
+        cpg.generate_code(self.problem, code_dir=code_dir, solver=cp.CLARABEL, wrapper=False)
+        return code_dir
+
+    def update_parameter(self, param_name, new_value):
+        """
+        Update a parameter value.
+        
+        Args:
+            param_name (str): Name of the parameter to update
+            new_value: New value for the parameter
+        """
+        if param_name not in self.parameters:
+            raise ValueError(f"Parameter {param_name} not found")
+            
+        self.parameters[param_name].value = new_value
+    
+    def update_config(self, **kwargs):
+        """
+        Update configuration parameters and rebuild the problem.
+        
+        Args:
+            **kwargs: Configuration parameters to update
+        """
+        self.config._process_kwargs(kwargs)
+        
+        # Rebuild the problem with updated configuration
+        self._setup_problem()

gfold/visualization.py

@@ -0,0 +1,90 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_results(solution, save_path=None, show=True):
+    """
+    Plot the results of the G-FOLD solver.
+    
+    Args:
+        solution (dict): Solution from GFoldSolver.solve()
+        save_path (str, optional): Path to save the figure
+        show (bool): Whether to show the plot
+        
+    Returns:
+        matplotlib.figure.Figure: The created figure
+    """
+    positions = solution["positions"]
+    velocities = solution["velocities"]
+    thrusts = solution["normalized_thrusts"]
+    time_points = solution["time_points"]
+    
+    x = positions[:, 0]
+    y = positions[:, 1]
+    z = positions[:, 2]
+    
+    fig = plt.figure(figsize=(12, 10))
+    
+    # 3D trajectory plot
+    ax = fig.add_subplot(221, projection='3d')
+    ax.plot(x, y, z, "red", label="path")
+    
+    # Calculate and plot the glide slope cone
+    initial_height = positions[0, 2]
+    sin_glide_slope = 0  # Default value, can be passed from the solver
+    
+    if initial_height > 0:
+        cosx = np.sqrt(1-np.square(sin_glide_slope))
+        theta = np.arange(0, 2*np.pi, np.pi/100)
+        radius = np.sqrt(1-np.square(cosx))/cosx * initial_height if cosx > 0 else initial_height
+        z_values = np.arange(0, initial_height, initial_height/20)
+        
+        for count, zval in enumerate(z_values):
+            x_vals = np.cos(theta) * (count+1)/20 * radius
+            y_vals = np.sin(theta) * (count+1)/20 * radius
+            ax.plot(x_vals, y_vals, zval, '#0000FF55')
+    
+    ax.legend(loc="center left", bbox_to_anchor=(2, 0.5))
+    ax.set_xlim3d(-initial_height*0.6, initial_height*0.6)
+    ax.set_ylim3d(-initial_height*0.6, initial_height*0.6)
+    ax.set_zlim3d(0, initial_height*1.2)
+    ax.set_xlabel('X')
+    ax.set_ylabel('Y')
+    ax.set_zlabel('Z')
+    ax.set_title('3D Trajectory')
+    
+    # Velocity plot
+    ax = fig.add_subplot(222)
+    v = np.linalg.norm(velocities, axis=1)
+    ax.plot(time_points, velocities[:, 2], label="Z velocity")
+    ax.plot(time_points, v, label="Total velocity")
+    ax.set_xlabel('Time (s)')
+    ax.set_ylabel('Velocity (m/s)')
+    ax.set_title('Velocity Profile')
+    ax.legend()
+    
+    # Thrust plot
+    ax = fig.add_subplot(223)
+    ax.plot(time_points, thrusts*100, label="thrust %")
+    ax.set_ylim(0, 100)
+    ax.set_xlabel('Time (s)')
+    ax.set_ylabel('Thrust (%)')
+    ax.set_title('Thrust Profile')
+    ax.legend()
+    
+    # Ground trajectory
+    ax = fig.add_subplot(224)
+    ax.plot(positions[:, 0], positions[:, 1], label="ground trajectory")
+    ax.set_xlabel('X (m)')
+    ax.set_ylabel('Y (m)')
+    ax.set_title('Ground Track')
+    ax.legend()
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path)
+    
+    if show:
+        plt.show()
+        
+    return fig

gfold-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: gfold
+Version: 0.1.0
+Summary: G-FOLD: Fuel Optimal Large Divert Guidance Algorithm
+Author-email: Samu Toljamo <samu.toljamo@gmail.com>
+Project-URL: Homepage, https://github.com/samutoljamo/g-fold
+Project-URL: Bug Tracker, https://github.com/samutoljamo/g-fold/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: cvxpy
+Requires-Dist: cvxpygen
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: jinja2
+
+# G-FOLD Python Generator
+
+This is the Python implementation of the G-FOLD algorithm with code generation capabilities. The problem is described using CVXPY/Python and C/C++ code is generated using CVXPYGen.
+
+## Installation
+
+### Option 1: Install from source
+
+#### Prerequisites
+
+You need to install [Rust](https://www.rust-lang.org/tools/install) and [Eigen](https://github.com/oxfordcontrol/Clarabel.cpp#installation) for the code generation feature.
+
+Clone the repository:
+
+```bash
+git clone https://github.com/samutoljamo/g-fold.git
+cd g-fold/generator
+```
+
+Install the package in development mode:
+
+```bash
+pip install -e .
+```
+
+On WSL, make sure you've installed Tkinter (version depends on the python version you're using):
+```bash
+sudo apt-get install python3.12-tk
+```
+
+### Option 2: Install from PyPI (coming soon)
+
+```bash
+pip install gfold
+```
+
+## Usage
+
+### As a command-line tool
+
+After installation, you can run G-FOLD from the command line:
+
+```bash
+# Solve the example problem with 100 steps and display graphs
+gfold -n 100
+
+# Generate C++ code
+gfold -g -n 100 -o output_directory
+
+# Save the plot to a file without displaying it
+gfold -n 100 --save-plot --no-plot
+```
+
+### As a Python library
+
+```python
+from gfold import GFoldSolver
+from gfold.visualization import plot_results
+
+# Create a solver with 100 steps
+solver = GFoldSolver()
+
+# Solve the problem
+solution = solver.solve(verbose=True)
+print(f"Final mass: {solution['final_mass']:.2f} kg")
+
+# Plot the results
+plot_results(solution, save_path="gfold_plot.png")
+
+# Generate C++ code
+solver.generate_code(code_dir="generated_code")
+```
+
+### Example scripts
+
+Check the `examples` directory for more usage examples:
+
+- `simple_example.py`: Basic usage of the solver and visualization
+
+## Development
+
+To set up the development environment:
+
+```bash
+cd g-fold/generator
+pip install -e .
+```

gfold-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+gfold/__init__.py,sha256=yaVDQITf3aXyJQ3VGc5_1nAhkrF1nXYZC_L5PtahtPE,148
+gfold/cli.py,sha256=2MtcnkIVqYj-6RyMMRWlLEu2QfDSKS9Iiq2LGlZN5uw,1887
+gfold/config.py,sha256=ByXu8UKvXpps0QiKZdjds4RC5O_Eq18aGHj7svUg9d0,7797
+gfold/solver.py,sha256=do1zHlXCHOiDiVa-Ppm1KYnak9KIL2Vi7VTD-KIFUgI,9159
+gfold/visualization.py,sha256=WQudybLpB84IU1t5wCFY3QRgH9WzLkMBTxV4_3Ob7-Y,2795
+gfold-0.1.0.dist-info/METADATA,sha256=Ko3xl8DIMu6QUiWjrlX-Y_DhfJ0exRFT7YLex-Xyq8g,2483
+gfold-0.1.0.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+gfold-0.1.0.dist-info/entry_points.txt,sha256=4dEXUic5CtbWhA8R0iAzZdejerZVrJiAypGu29bKWz4,41
+gfold-0.1.0.dist-info/top_level.txt,sha256=jBTUZKxNhllKQx0iJklVZaGOF6mASvtHK5C00VrSpwk,6
+gfold-0.1.0.dist-info/RECORD,,

gfold-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.0.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gfold-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gfold = gfold.cli:main

gfold-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gfold