ballistic-solve 0.0.1__tar.gz → 0.2.0__tar.gz

{ballistic_solve-0.0.1 → ballistic_solve-0.2.0}/CMakeLists.txt

@@ -1,8 +1,5 @@
 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.2.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.2
+Name: ballistic-solve
+Version: 0.2.0
+Summary: Real-time numerical solver for moving target interception with realistic ballistic trajectory
+Keywords: ballistic,trajectory,projectile,physics-simulation,ballistics-solver,ode-solver,numerical-integration,root-finding,optimization,fire-control,targeting,intercept,weapon-systems,aerospace,drag-coefficient,atmospheric-effects,wind-compensation,gravity,adaptive-stepping,real-time,scientific-computing
+Author-Email: Ariyudo Pertama <yudojago@gmail.com>
+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.
+         
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+   <picture>
+     <source media="(prefers-color-scheme: dark)" srcset="docs/images/hero-dark.png">
+     <source media="(prefers-color-scheme: light)" srcset="docs/images/hero-dark.png">
+     <img alt="ballistic-solve" src="docs/images/hero-light.png" width="70%">
+   </picture>
+   
+   [![PyPI](https://img.shields.io/pypi/v/ballistic-solve.svg)](https://pypi.org/project/ballistic-solve/)
+   [![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+   [![C++](https://img.shields.io/badge/C++-20-00599C.svg)](https://isocpp.org/)
+   [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+   
+</div>
+
+**ballistic-solve** is a high-performance C++ library with Python bindings for computing ballistic trajectories and firing solutions. It solves intercept problems for moving targets while modeling real-world physics including gravity, drag, wind, and atmospheric variations.
+
+### Key Features
+
+- **Real-world physics** — Account for gravity, air resistance, wind, and atmospheric conditions
+- **Moving targets interception** — Calculate firing solutions to intercept targets with any motion pattern
+- **High performance** — Fast C++ core with Eigen for real-time trajectory computation
+
+---
+
+## Installation
+
+```bash
+pip install ballistic-solve
+```
+
+---
+
+## Quick Start
+
+```python
+import numpy as np
+from ballistic_solve import Ballistic, Environment, Projectile
+
+environment = Environment.earth_standard()
+projectile = Projectile.gsh30_round()
+
+ballistic = Ballistic(environment, projectile)
+
+def target_position(t):
+    p = np.array([1200.0, 150.0, 5200.0])
+    v = np.array([270.0, 20.0, -5.0])
+    a = np.array([0.0, -15.0, -2.0])
+
+    return p + v * t + 0.5 * a * t**2
+
+solution = ballistic.solve_earliest(
+    target_position=target_position,
+    platform_position=np.array([0.0, 0.0, 5000.0]),
+    platform_velocity=np.array([250.0, 0.0, 0.0]),
+    projectile_speed=860.0,
+    time_range=(0.0, 5.0)
+)
+
+if solution:
+    print(f"Fire direction: {solution.direction}")
+    print(f"Time to intercept: {solution.time:.3f}s")
+    print(f"Interception error: {solution.error:.4e}m")
+    print(f"Computation time: {solution.computation_time * 1e3:.2f}ms")
+else:
+    print("No solution")
+```
+
+---
+
+## Dependencies
+
+- **Eigen** — Vectorized linear algebra and Levenberg-Marquardt optimization
+- **Boost** — Adaptive-step ODE integration and root-finding
+
+---
+
+## License
+
+[MIT](LICENSE) © Ariyudo Pertama

ballistic_solve-0.2.0/README.md

@@ -0,0 +1,80 @@
+<div align="center">
+
+   <picture>
+     <source media="(prefers-color-scheme: dark)" srcset="docs/images/hero-dark.png">
+     <source media="(prefers-color-scheme: light)" srcset="docs/images/hero-dark.png">
+     <img alt="ballistic-solve" src="docs/images/hero-light.png" width="70%">
+   </picture>
+   
+   [![PyPI](https://img.shields.io/pypi/v/ballistic-solve.svg)](https://pypi.org/project/ballistic-solve/)
+   [![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+   [![C++](https://img.shields.io/badge/C++-20-00599C.svg)](https://isocpp.org/)
+   [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+   
+</div>
+
+**ballistic-solve** is a high-performance C++ library with Python bindings for computing ballistic trajectories and firing solutions. It solves intercept problems for moving targets while modeling real-world physics including gravity, drag, wind, and atmospheric variations.
+
+### Key Features
+
+- **Real-world physics** — Account for gravity, air resistance, wind, and atmospheric conditions
+- **Moving targets interception** — Calculate firing solutions to intercept targets with any motion pattern
+- **High performance** — Fast C++ core with Eigen for real-time trajectory computation
+
+---
+
+## Installation
+
+```bash
+pip install ballistic-solve
+```
+
+---
+
+## Quick Start
+
+```python
+import numpy as np
+from ballistic_solve import Ballistic, Environment, Projectile
+
+environment = Environment.earth_standard()
+projectile = Projectile.gsh30_round()
+
+ballistic = Ballistic(environment, projectile)
+
+def target_position(t):
+    p = np.array([1200.0, 150.0, 5200.0])
+    v = np.array([270.0, 20.0, -5.0])
+    a = np.array([0.0, -15.0, -2.0])
+
+    return p + v * t + 0.5 * a * t**2
+
+solution = ballistic.solve_earliest(
+    target_position=target_position,
+    platform_position=np.array([0.0, 0.0, 5000.0]),
+    platform_velocity=np.array([250.0, 0.0, 0.0]),
+    projectile_speed=860.0,
+    time_range=(0.0, 5.0)
+)
+
+if solution:
+    print(f"Fire direction: {solution.direction}")
+    print(f"Time to intercept: {solution.time:.3f}s")
+    print(f"Interception error: {solution.error:.4e}m")
+    print(f"Computation time: {solution.computation_time * 1e3:.2f}ms")
+else:
+    print("No solution")
+```
+
+---
+
+## Dependencies
+
+- **Eigen** — Vectorized linear algebra and Levenberg-Marquardt optimization
+- **Boost** — Adaptive-step ODE integration and root-finding
+
+---
+
+## License
+
+[MIT](LICENSE) © Ariyudo Pertama

ballistic_solve-0.2.0/core/CMakeLists.txt

@@ -0,0 +1,46 @@
+cmake_minimum_required(VERSION 4.2)
+project(
+    ballistic_solve_core
+    VERSION 0.2.0
+    LANGUAGES CXX
+)
+
+find_package(Boost REQUIRED)
+find_package(Eigen3 REQUIRED)
+
+add_library(ballistic_solve_core STATIC
+    src/ballistic.cpp
+    src/environment.cpp
+    src/projectile.cpp
+    src/utility.cpp
+)
+
+target_sources(ballistic_solve_core
+    PUBLIC
+        FILE_SET HEADERS
+        BASE_DIRS include
+        FILES
+            include/ballistic_solve/ballistic.hpp
+            include/ballistic_solve/environment.hpp
+            include/ballistic_solve/projectile.hpp
+            include/ballistic_solve/utility.hpp
+            include/ballistic_solve/constants.hpp
+)
+
+target_include_directories(ballistic_solve_core
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(ballistic_solve_core
+    PUBLIC
+        Boost::boost
+        Eigen3::Eigen
+)
+
+target_compile_features(ballistic_solve_core PUBLIC cxx_std_20)
+
+set_target_properties(ballistic_solve_core PROPERTIES 
+    POSITION_INDEPENDENT_CODE ON
+)

ballistic_solve-0.2.0/core/include/ballistic_solve/ballistic.hpp

@@ -0,0 +1,266 @@
+#ifndef BALLISTIC_SOLVE_BALLISTIC_HPP
+#define BALLISTIC_SOLVE_BALLISTIC_HPP
+
+#include "./environment.hpp"
+#include "./projectile.hpp"
+#include <Eigen/dense>
+#include <optional>
+#include <functional>
+#include <vector>
+
+namespace ballistic_solve
+{
+    /**
+     * @brief Ballistic trajectory solver for projectile motion with environmental effects.
+     *
+     * This class provides methods to simulate projectile trajectories and solve firing
+     * solutions for moving or stationary targets. It accounts for gravity, air drag,
+     * wind, and other environmental factors.
+     */
+    class Ballistic
+    {
+    private:
+        /**
+         * @brief State vector representation: [position_x, position_y, position_z, velocity_x, velocity_y, velocity_z]
+         */
+        using State = Eigen::Matrix<double, 6, 1>;
+
+        /**
+         * @brief Function type for time-varying target position.
+         *
+         * @param time Time in seconds
+         * @return Target position vector at the given time
+         */
+        using TargetPosition = std::function<Eigen::Vector3d(double)>;
+
+    public:
+        /**
+         * @brief Contains the computed trajectory of a projectile.
+         */
+        struct Trajectory
+        {
+            /** @brief Sequence of 3D positions along the trajectory in meters */
+            const std::vector<Eigen::Vector3d> positions;
+
+            /** @brief Corresponding time values for each position in seconds */
+            const std::vector<double> times;
+        };
+
+        /**
+         * @brief Contains a firing solution for intercepting a target.
+         */
+        struct Solution
+        {
+            /** @brief Unit direction vector to aim the projectile */
+            const Eigen::Vector3d direction;
+
+            /** @brief Time of intercept in seconds */
+            const double time;
+
+            /** @brief Intercept error in meters */
+            const double error;
+
+            /** @brief Computation time in seconds */
+            const double computation_time;
+        };
+
+    public:
+        /** @brief Environmental conditions affecting the projectile */
+        const Environment environment;
+
+        /** @brief Physical properties of the projectile */
+        const Projectile projectile;
+
+    public:
+        /**
+         * @brief Constructs a ballistic solver with given environment and projectile.
+         *
+         * @param environment Environmental conditions (gravity, air density, wind, temperature)
+         * @param projectile Projectile properties (mass, area, drag coefficient)
+         */
+        Ballistic(
+            Environment environment,
+            Projectile projectile);
+
+    public:
+        /**
+         * @brief Simulates projectile trajectory over a time range with specified direction.
+         *
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param direction Unit direction vector for the projectile launch
+         * @param time_range Time interval [start, end] for simulation in seconds
+         * @return Trajectory containing positions and times along the flight path
+         */
+        [[nodiscard]] Trajectory simulate(
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            const Eigen::Vector3d &direction,
+            std::pair<double, double> time_range) const;
+
+        /**
+         * @brief Simulates projectile trajectory over a time range with specified angles.
+         *
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param angles Launch angles [azimuth, elevation] in radians
+         * @param time_range Time interval [start, end] for simulation in seconds
+         * @return Trajectory containing positions and times along the flight path
+         */
+        [[nodiscard]] Trajectory simulate(
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            const Eigen::Vector2d &angles,
+            std::pair<double, double> time_range) const;
+
+        /**
+         * @brief Simulates projectile position at a specific time with specified direction.
+         *
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param direction Unit direction vector for the projectile launch
+         * @param time Time at which to compute position in seconds
+         * @return Projectile position at the specified time in meters
+         */
+        [[nodiscard]] Eigen::Vector3d simulate(
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            const Eigen::Vector3d &direction,
+            double time) const;
+
+        /**
+         * @brief Simulates projectile position at a specific time with specified angles.
+         *
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param angles Launch angles [azimuth, elevation] in radians
+         * @param time Time at which to compute position in seconds
+         * @return Projectile position at the specified time in meters
+         */
+        [[nodiscard]] Eigen::Vector3d simulate(
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            const Eigen::Vector2d &angles,
+            double time) const;
+
+        /**
+         * @brief Finds the earliest firing solution to intercept a moving target.
+         *
+         * Searches for the earliest time within the specified range where the projectile
+         * can intercept the target. Uses a time-scanning approach with the given interval.
+         *
+         * @param target_position Function providing target position as a function of time
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param time_range Time interval [start, end] to search for solutions in seconds
+         * @param time_scan_interval Time step for scanning potential intercept times (default: 0.5 s)
+         * @return Optional Solution containing firing direction and intercept time, or nullopt if no solution exists
+         */
+        [[nodiscard]] std::optional<Solution> solve_earliest(
+            TargetPosition target_position,
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            std::pair<double, double> time_range,
+            double time_scan_interval = 0.5) const;
+
+        /**
+         * @brief Finds the latest firing solution to intercept a moving target.
+         *
+         * Searches for the latest time within the specified range where the projectile
+         * can intercept the target. Uses a time-scanning approach with the given interval.
+         *
+         * @param target_position Function providing target position as a function of time
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param time_range Time interval [start, end] to search for solutions in seconds
+         * @param time_scan_interval Time step for scanning potential intercept times (default: 0.5 s)
+         * @return Optional Solution containing firing direction and intercept time, or nullopt if no solution exists
+         */
+        [[nodiscard]] std::optional<Solution> solve_latest(
+            TargetPosition target_position,
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            std::pair<double, double> time_range,
+            double time_scan_interval = 0.5) const;
+
+        /**
+         * @brief Finds optimal launch angles to hit a stationary target at a specific time.
+         *
+         * Computes the azimuth and elevation angles that minimize the intercept error
+         * for reaching the target position at the specified time.
+         *
+         * @param target_position Position of the target in meters
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param time Time at which intercept should occur in seconds
+         * @return Optimal launch angles [azimuth, elevation] in radians
+         */
+        [[nodiscard]] Eigen::Vector2d find_best_angles(
+            const Eigen::Vector3d &target_position,
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            double time) const;
+        
+        /**
+         * @brief Finds optimal launch direction to hit a stationary target at a specific time.
+         *
+         * Computes the direction that minimize the intercept error
+         * for reaching the target position at the specified time.
+         *
+         * @param target_position Position of the target in meters
+         * @param platform_position Initial position of the launching platform in meters
+         * @param platform_velocity Velocity of the launching platform in m/s
+         * @param projectile_speed Muzzle speed of the projectile relative to platform in m/s
+         * @param time Time at which intercept should occur in seconds
+         * @return Optimal launch direction
+         */
+        [[nodiscard]] Eigen::Vector3d find_best_direction(
+            const Eigen::Vector3d &target_position,
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            double time) const;
+
+    private:
+        void system(const State &x, State &dxdt, double time) const;
+
+        [[nodiscard]] Trajectory simulate(
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            const Eigen::Vector3d &direction,
+            bool is_normalized_direction,
+            std::pair<double, double> time_range) const;
+
+        [[nodiscard]] Eigen::Vector3d simulate(
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            const Eigen::Vector3d &direction,
+            bool is_normalized_direction,
+            double time) const;
+
+        [[nodiscard]] double intercept_error(
+            Ballistic::TargetPosition target_position,
+            const Eigen::Vector3d &platform_position,
+            const Eigen::Vector3d &platform_velocity,
+            double projectile_speed,
+            double time) const;
+    };
+}
+
+#endif // BALLISTIC_SOLVE_BALLISTIC_HPP

ballistic_solve-0.2.0/core/include/ballistic_solve/constants.hpp

@@ -0,0 +1,29 @@
+#ifndef BALLISTIC_SOLVE_CONSTANTS_HPP
+#define BALLISTIC_SOLVE_CONSTANTS_HPP
+
+#include <boost/math/tools/roots.hpp>
+#include <limits>
+
+namespace ballistic_solve
+{
+    namespace constants
+    {
+        inline constexpr int digits = std::numeric_limits<double>::digits;
+        inline constexpr double h = 1e-6;
+
+        namespace root_finding {
+            inline const boost::math::tools::eps_tolerance<double> tolerance(digits);
+            inline constexpr std::uintmax_t max_iterations = 40;
+        }
+
+        namespace integration
+        {
+            inline constexpr double max_step_size = std::numeric_limits<double>::infinity();
+            inline constexpr double initial_step_size = 1e-3;
+            inline constexpr double abs_tolerance = 1e-6;
+            inline constexpr double rel_tolerance = 1e-3;
+        }
+    }
+}
+
+#endif // BALLISTIC_SOLVE_CONSTANTS_HPP