ballistic-solve 0.0.1__tar.gz

ballistic_solve-0.0.1/.gitignore

@@ -0,0 +1,71 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+.installed.cfg
+*.egg
+dist/
+build/
+*.whl
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+.pixi/
+
+# IDEs
+.vscode/
+.idea/
+
+# CMake
+.cmake/
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+Makefile
+*.vcxproj
+*.vcxproj.filters
+*.sln
+
+# Build directories
+build/
+out/
+Debug/
+Release/
+RelWithDebInfo/
+MinSizeRel/
+
+# Compiled binaries
+*.exe
+*.dll
+*.dylib
+*.so
+*.pyd
+
+# OS
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+*.cover
+
+# Environment files
+.env
+.envrc
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Numba cache (from your __pycache__ listing)
+*.nbc
+*.nbi

ballistic_solve-0.0.1/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 4.2)
+project(ballistic-solve)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_subdirectory(core)
+add_subdirectory(python)

ballistic_solve-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ariyudo Pertama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ballistic_solve-0.0.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.2
+Name: ballistic-solve
+Version: 0.0.1
+Summary: Ballistic trajectory solver with C++ core and Python bindings
+License: MIT License
+         
+         Copyright (c) 2026 Ariyudo Pertama
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Requires-Python: >=3.12
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# ballistic-solve
+
+Ballistic trajectory simulation and fire control solutions.
+
+## Development Setup
+
+### Prerequisites
+- Miniforge (or Conda/Miniconda)
+
+### Installation
+
+1. **Create the conda environment:**
+```bat
+   conda env create --file environment.yml
+```
+
+2. **Activate the environment:**
+```bat
+   conda activate ballistic-solve
+```
+
+### Development
+
+Work in progress. More documentation coming soon.
+
+## License
+
+MIT

ballistic_solve-0.0.1/README.md

@@ -0,0 +1,28 @@
+# ballistic-solve
+
+Ballistic trajectory simulation and fire control solutions.
+
+## Development Setup
+
+### Prerequisites
+- Miniforge (or Conda/Miniconda)
+
+### Installation
+
+1. **Create the conda environment:**
+```bat
+   conda env create --file environment.yml
+```
+
+2. **Activate the environment:**
+```bat
+   conda activate ballistic-solve
+```
+
+### Development
+
+Work in progress. More documentation coming soon.
+
+## License
+
+MIT

ballistic_solve-0.0.1/core/CMakeLists.txt

@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 4.2)
+project(
+    ballistic_solve_core
+    VERSION 0.0.0
+    LANGUAGES CXX
+)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(Boost REQUIRED)
+find_package(Eigen3 REQUIRED)
+
+set(BALLISTIC_SOLVE_CORE_HEADERS
+    include/ballistic-solve/environment.hpp
+    include/ballistic-solve/platform.hpp
+    include/ballistic-solve/projectile.hpp
+    include/ballistic-solve/simulation.hpp
+    include/ballistic-solve/trajectory.hpp
+    include/ballistic-solve/targeting.hpp
+    include/ballistic-solve/tools.hpp
+)
+
+set(BALLISTIC_SOLVE_CORE_SOURCES
+    src/environment.cpp
+    src/platform.cpp
+    src/projectile.cpp
+    src/simulation.cpp
+    src/trajectory.cpp
+    src/targeting.cpp
+    src/tools.cpp
+)
+
+set(PRIVATE_REQUIRED_EXTERNAL_LIBRARIES
+    Boost::boost
+)
+
+set(PUBLIC_REQUIRED_EXTERNAL_LIBRARIES
+    Eigen3::Eigen
+)
+
+add_library(ballistic_solve_core STATIC)
+
+target_sources(ballistic_solve_core
+    PUBLIC
+        ${BALLISTIC_SOLVE_CORE_HEADERS}
+    PRIVATE
+        ${BALLISTIC_SOLVE_CORE_SOURCES}
+)
+
+target_include_directories(ballistic_solve_core
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(ballistic_solve_core
+    PRIVATE
+        ${PRIVATE_REQUIRED_EXTERNAL_LIBRARIES}
+    PUBLIC
+        ${PUBLIC_REQUIRED_EXTERNAL_LIBRARIES}
+)
+
+set_target_properties(ballistic_solve_core PROPERTIES POSITION_INDEPENDENT_CODE ON)

ballistic_solve-0.0.1/core/include/ballistic-solve/environment.hpp

@@ -0,0 +1,124 @@
+#ifndef BALLISTIC_SOLVE_ENVIRONMENT_HPP
+#define BALLISTIC_SOLVE_ENVIRONMENT_HPP
+
+#include <functional>
+#include <optional>
+#include <Eigen/Dense>
+
+namespace ballistic_solve
+{
+    /**
+     * @brief Environmental conditions for ballistic simulation.
+     *
+     * Encapsulates atmospheric and gravitational conditions affecting projectile motion,
+     * including gravity, altitude-dependent air density, and wind velocity.
+     */
+    class Environment
+    {
+    public:
+        /// Function type for air density as a function of altitude: ρ(h) in kg/m³
+        using AirDensity = std::function<double(double)>;
+
+        /// Gravitational acceleration vector in m/s² (typically [0, 0, -9.81])
+        const Eigen::Vector3d gravity;
+
+        /// Air density function ρ(altitude) in kg/m³, where altitude is in meters
+        const AirDensity air_density;
+
+        /// Wind velocity vector in m/s
+        const Eigen::Vector3d wind_velocity;
+
+        /**
+         * @brief Construct a custom environment.
+         *
+         * @param gravity Gravitational acceleration vector (m/s²)
+         * @param air_density Function mapping altitude (m) to air density (kg/m³)
+         * @param wind_velocity Wind velocity vector (m/s)
+         */
+        Environment(
+            const Eigen::Vector3d &gravity,
+            const AirDensity &air_density,
+            const Eigen::Vector3d &wind_velocity);
+
+        /**
+         * @brief Create a vacuum environment (no air, no wind).
+         *
+         * Uses standard gravity but zero air density everywhere.
+         * Useful for testing or space-like conditions.
+         *
+         * @return Environment Vacuum environment with g = -9.81 m/s²
+         */
+        static Environment vacuum();
+
+        /**
+         * @brief Create standard Earth atmosphere at sea level.
+         *
+         * Uses:
+         * - Standard gravity: 9.81 m/s² (downward)
+         * - Exponential atmosphere: ρ(h) = 1.225 * exp(-h/8500) kg/m³
+         * - No wind
+         *
+         * @return Environment Standard Earth conditions
+         */
+        static Environment standard();
+
+        /**
+         * @brief Create standard atmosphere with moderate random wind.
+         *
+         * Wind is sampled from normal distributions:
+         * - Horizontal components (x, y): σ = 10 m/s (~22 mph)
+         * - Vertical component (z): σ = 1 m/s
+         *
+         * Represents typical windy day conditions.
+         *
+         * @param seed Optional random seed for reproducibility
+         * @return Environment Standard conditions with moderate random wind
+         */
+        static Environment standard_with_random_wind(std::optional<unsigned int> seed = std::nullopt);
+
+        /**
+         * @brief Create standard atmosphere with strong random wind.
+         *
+         * Wind is sampled from normal distributions:
+         * - Horizontal components (x, y): σ = 25 m/s (~56 mph)
+         * - Vertical component (z): σ = 5 m/s
+         *
+         * Represents tropical storm or gale force wind conditions.
+         *
+         * @param seed Optional random seed for reproducibility
+         * @return Environment Standard conditions with strong random wind
+         */
+        static Environment standard_with_random_strong_wind(std::optional<unsigned int> seed = std::nullopt);
+
+        /**
+         * @brief Create standard atmosphere with extreme random wind.
+         *
+         * Wind is sampled from normal distributions:
+         * - Horizontal components (x, y): σ = 50 m/s (~112 mph)
+         * - Vertical component (z): σ = 10 m/s
+         *
+         * Represents Category 3 hurricane conditions.
+         *
+         * @param seed Optional random seed for reproducibility
+         * @return Environment Standard conditions with extreme random wind
+         */
+        static Environment standard_with_random_extreme_wind(std::optional<unsigned int> seed = std::nullopt);
+
+        /**
+         * @brief Create standard atmosphere with catastrophic random wind.
+         *
+         * Wind is sampled from normal distributions:
+         * - Horizontal components (x, y): σ = 100 m/s (~224 mph)
+         * - Vertical component (z): σ = 20 m/s
+         *
+         * Represents Category 5+ hurricane or strongest tornado conditions.
+         * Useful for stress testing numerical stability.
+         *
+         * @param seed Optional random seed for reproducibility
+         * @return Environment Standard conditions with catastrophic random wind
+         */
+        static Environment standard_with_random_catastrophic_wind(std::optional<unsigned int> seed = std::nullopt);
+    };
+}
+
+#endif // BALLISTIC_SOLVE_ENVIRONMENT_HPP

ballistic_solve-0.0.1/core/include/ballistic-solve/platform.hpp

@@ -0,0 +1,43 @@
+#ifndef BALLISTIC_SOLVE_PLATFORM_HPP
+#define BALLISTIC_SOLVE_PLATFORM_HPP
+
+#include <Eigen/Dense>
+
+namespace ballistic_solve
+{
+    /**
+     * @brief Launch platform properties for ballistic simulation.
+     * 
+     * Represents the firing platform (e.g., ground position, moving vehicle, aircraft)
+     * including its position, velocity, and the muzzle velocity of the weapon system.
+     * The projectile's initial velocity is the vector sum of platform velocity and
+     * muzzle velocity in the launch direction.
+     */
+    class Platform
+    {
+    public:
+        /// Position of the launch platform in 3D space (meters)
+        const Eigen::Vector3d position;
+        
+        /// Velocity of the platform itself (m/s). For stationary platforms, this is zero.
+        const Eigen::Vector3d velocity;
+
+        /// Muzzle velocity magnitude (m/s). Speed of projectile relative to platform.
+        const double muzzle_velocity;
+
+    public:
+        /**
+         * @brief Construct a launch platform.
+         * 
+         * @param position 3D position vector in meters
+         * @param velocity 3D velocity vector in m/s (platform motion)
+         * @param muzzle_velocity Scalar muzzle velocity in m/s (projectile speed relative to platform)
+         */
+        Platform(
+            const Eigen::Vector3d &position,
+            const Eigen::Vector3d &velocity,
+            const double muzzle_velocity);
+    };
+}
+
+#endif // BALLISTIC_SOLVE_PLATFORM_HPP

ballistic_solve-0.0.1/core/include/ballistic-solve/projectile.hpp

@@ -0,0 +1,41 @@
+#ifndef BALLISTIC_SOLVE_PROJECTILE_HPP
+#define BALLISTIC_SOLVE_PROJECTILE_HPP
+
+namespace ballistic_solve
+{
+    /**
+     * @brief Physical properties of a projectile for ballistic simulation.
+     * 
+     * Encapsulates the mass, cross-sectional area, and drag coefficient
+     * needed to compute aerodynamic forces during flight.
+     */
+    class Projectile
+    {
+    public:
+        /// Mass of the projectile in kilograms
+        const double mass;
+        
+        /// Cross-sectional area in square meters (perpendicular to velocity)
+        const double area;
+        
+        /// Dimensionless drag coefficient (Cd). Typical values:
+        /// - Sphere: ~0.47
+        /// - Streamlined body: ~0.04
+        /// - Flat plate: ~1.28
+        const double drag_coefficient;
+
+        /**
+         * @brief Construct a projectile with specified properties.
+         * 
+         * @param mass Mass in kilograms (default: 1 kg)
+         * @param area Cross-sectional area in square meters (default: 1 m²)
+         * @param drag_coefficient Dimensionless drag coefficient (default: 0.47, sphere)
+         */
+        Projectile(
+            const double mass = 1.0,
+            const double area = 1.0,
+            const double drag_coefficient = 0.47);
+    };
+}
+
+#endif // BALLISTIC_SOLVE_PROJECTILE_HPP

ballistic_solve-0.0.1/core/include/ballistic-solve/simulation.hpp

@@ -0,0 +1,132 @@
+#ifndef BALLISTIC_SOLVE_SIMULATION_HPP
+#define BALLISTIC_SOLVE_SIMULATION_HPP
+
+#include "ballistic-solve/environment.hpp"
+#include "ballistic-solve/projectile.hpp"
+#include "ballistic-solve/trajectory.hpp"
+#include "ballistic-solve/platform.hpp"
+
+#include <Eigen/Dense>
+#include <utility>
+
+namespace ballistic_solve
+{
+    /**
+     * @brief Configuration for the adaptive ODE integrator.
+     *
+     * Controls the Dormand-Prince (DOPRI5) Runge-Kutta adaptive integration_options
+     * used for trajectory integration.
+     */
+    struct IntegrationOptions
+    {
+        const double max_step = 1e3;    ///< Maximum step size (seconds)
+        const double first_step = 1e-3; ///< Initial step size (seconds)
+        const double atol = 1e-6;       ///< Absolute error tolerance
+        const double rtol = 1e-3;       ///< Relative error tolerance
+    };
+
+    /**
+     * @brief Convert spherical coordinates to 3D direction vector.
+     *
+     * @param angles Pair of (azimuth, elevation) angles in radians
+     * @return Eigen::Vector3d Unit direction vector
+     */
+    Eigen::Vector3d to_direction(const std::pair<double, double> &angles);
+
+    /**
+     * @brief Convert 3D direction vector to spherical coordinates.
+     *
+     * @param direction Direction vector (need not be normalized)
+     * @return std::pair<double, double> (azimuth, elevation) in radians
+     */
+    std::pair<double, double> to_angles(const Eigen::Vector3d &direction);
+
+    /**
+     * @brief Compute complete ballistic trajectory with recorded time steps.
+     *
+     * Simulates projectile motion under gravity, drag, and wind effects using
+     * adaptive Runge-Kutta integration. Records position at each integration step.
+     *
+     * @param environment Environmental conditions (gravity, air density, wind)
+     * @param projectile Projectile properties (mass, drag coefficient, area)
+     * @param platform Launch platform (position, velocity, muzzle velocity)
+     * @param direction Unit vector indicating launch direction
+     * @param time Simulation time (seconds)
+     * @param integration_options Integration parameters (step sizes, tolerances)
+     * @return Trajectory Complete trajectory with positions and times
+     */
+    Trajectory compute_trajectory(
+        const Environment &environment,
+        const Projectile &projectile,
+        const Platform &platform,
+        const Eigen::Vector3d &direction,
+        const double time,
+        const IntegrationOptions &integration_options = IntegrationOptions{});
+
+    /**
+     * @brief Compute complete ballistic trajectory from launch angles.
+     *
+     * Convenience overload that accepts spherical coordinates instead of
+     * direction vector.
+     *
+     * @param environment Environmental conditions
+     * @param projectile Projectile properties
+     * @param platform Launch platform
+     * @param angles Pair of (azimuth, elevation) angles in radians
+     * @param time Simulation time (seconds)
+     * @param integration_options Integration parameters
+     * @return Trajectory Complete trajectory with positions and times
+     */
+    Trajectory compute_trajectory(
+        const Environment &environment,
+        const Projectile &projectile,
+        const Platform &platform,
+        const std::pair<double, double> &angles,
+        const double time,
+        const IntegrationOptions &integration_options = IntegrationOptions{});
+
+    /**
+     * @brief Compute final position only (no trajectory recording).
+     *
+     * More efficient than compute_trajectory when only the endpoint is needed.
+     * Uses the same physics simulation but doesn't record intermediate steps.
+     *
+     * @param environment Environmental conditions
+     * @param projectile Projectile properties
+     * @param platform Launch platform
+     * @param direction Unit vector indicating launch direction
+     * @param time Simulation time (seconds)
+     * @param integration_options Integration parameters
+     * @return Eigen::Vector3d Final position after given simulation time
+     */
+    Eigen::Vector3d compute_point(
+        const Environment &environment,
+        const Projectile &projectile,
+        const Platform &platform,
+        const Eigen::Vector3d &direction,
+        const double time,
+        const IntegrationOptions &integration_options = IntegrationOptions{});
+
+    /**
+     * @brief Compute final position only from launch angles.
+     *
+     * Convenience overload that accepts spherical coordinates.
+     *
+     * @param environment Environmental conditions
+     * @param projectile Projectile properties
+     * @param platform Launch platform
+     * @param angles Pair of (azimuth, elevation) angles in radians
+     * @param time Simulation time (seconds)
+     * @param integration_options Integration parameters
+     * @return Eigen::Vector3d Final position after given simulation time
+     */
+    Eigen::Vector3d compute_point(
+        const Environment &environment,
+        const Projectile &projectile,
+        const Platform &platform,
+        const std::pair<double, double> &angles,
+        const double time,
+        const IntegrationOptions &integration_options = IntegrationOptions{});
+}
+
+#endif // BALLISTIC_SOLVE_SIMULATION_HPP