# Physics Simulation Algorithms in TheAlgorithms/Java: Complete Implementation Guide

> Explore physics simulation algorithms in TheAlgorithms/Java. Discover implementations for oscillators, projectile motion, collisions, and core physical laws. Master classical simulations.

- Repository: [The Algorithms/Java](https://github.com/TheAlgorithms/Java)
- Tags: how-to-guide
- Published: 2026-03-04

---

**Yes, TheAlgorithms/Java includes a dedicated `physics` package containing classical simulation algorithms for oscillators, projectile motion, elastic collisions, and fundamental physical laws.**

TheAlgorithms/Java serves as a comprehensive repository of computer science algorithms implemented in pure Java. Among its specialized collections, the **physics simulation algorithms** package provides stateless, immutable classes for modeling mechanical systems, trajectories, and forces—making it suitable for educational purposes, physics engines, and scientific computing projects.

## Overview of the Physics Package

All physics implementations reside in `src/main/java/com/thealgorithms/physics/`. The classes are designed as **pure-Java**, stateless utilities that encapsulate only immutable physical parameters. This architecture ensures thread safety and allows direct integration into larger applications or the provided JUnit test suites (e.g., `SimplePendulumRK4Test`).

## Core Physics Simulation Algorithms

### Oscillators and Harmonic Motion

The repository provides numerical and analytical solvers for oscillating systems. **`SimplePendulumRK4`** implements 4th-order Runge-Kutta integration to simulate nonlinear pendulum dynamics step-by-step. For damped systems, **`DampedOscillator`** offers a closed-form analytical solution for harmonic motion with friction.

### Projectile Motion Solvers

Two complementary classes handle ballistic trajectories. **`GroundToGroundProjectileMotion`** calculates simplified ground-to-ground trajectories using standard kinematic formulas. For arbitrary launch heights, **`ProjectileMotion`** computes comprehensive flight data including time of flight, horizontal range, and maximum apex—essential for robotics and game development.

### Collision Physics

The **`ElasticCollision2D`** class solves two-dimensional elastic collisions by applying conservation of momentum and kinetic energy. It accepts mass and velocity vectors for two bodies and returns the post-collision velocity vectors, enabling realistic physics responses without external dependencies.

### Fundamental Physical Laws

The package includes direct implementations of classical physics formulas:

- **`CoulombsLaw`** calculates electrostatic force between point charges
- **`Gravitation`** computes Newtonian gravitational attraction between masses
- **`SnellLaw`** determines refraction angles across media boundaries
- **`ThinLens`** provides optical imaging equations for focal length and magnification

### Kinematics Utilities

**`Kinematics`** supplies helper methods for unit conversions and basic motion equations, serving as a lightweight utility for coordinate transformations and velocity calculations.

## Implementation Examples

### Simulating a Simple Pendulum with RK4

The following example demonstrates numerical integration of a nonlinear pendulum using `SimplePendulumRK4`:

```java
import com.thealgorithms.physics.SimplePendulumRK4;

public class PendulumDemo {
    public static void main(String[] args) {
        // Length = 1 m, gravity = 9.81 m/s²
        SimplePendulumRK4 pendulum = new SimplePendulumRK4(1.0, 9.81);

        // Initial state: 30° (≈0.5236 rad) displacement, no initial angular velocity
        double[] state = new double[]{Math.toRadians(30), 0.0};

        // Simulate for 5 seconds with a step of 0.01 s
        double dt = 0.01;
        int steps = (int) (5.0 / dt);
        double[][] trajectory = pendulum.simulate(state, dt, steps);

        // Print the angle (degrees) at each second
        for (int i = 0; i <= steps; i += 100) {   // every 1 s
            double theta = Math.toDegrees(trajectory[i][0]);
            System.out.printf("t = %.2f s → θ = %.2f°%n", i * dt, theta);
        }
    }
}

```

### Computing Projectile Trajectories from Arbitrary Heights

This example calculates a projectile launched from an elevated position using `ProjectileMotion`:

```java
import com.thealgorithms.physics.ProjectileMotion;
import com.thealgorithms.physics.ProjectileMotion.Result;

public class ProjectileDemo {
    public static void main(String[] args) {
        double v0 = 50.0;               // m/s
        double angle = 45.0;            // degrees
        double height = 1.5;            // metres above ground

        Result r = ProjectileMotion.calculateTrajectory(v0, angle, height);
        System.out.printf("Time of flight: %.2f s%n", r.getTimeOfFlight());
        System.out.printf("Horizontal range: %.2f m%n", r.getHorizontalRange());
        System.out.printf("Maximum height: %.2f m%n", r.getMaxHeight());
    }
}

```

### Solving 2-D Elastic Collisions

The following code resolves a two-body elastic collision using `ElasticCollision2D`:

```java
import com.thealgorithms.physics.ElasticCollision2D;
import com.thealgorithms.physics.ElasticCollision2D.Velocity;

public class CollisionDemo {
    public static void main(String[] args) {
        // Masses (kg) and initial velocities (m/s)
        double m1 = 2.0, m2 = 1.0;
        Velocity v1 = new Velocity(3.0, 0.0);
        Velocity v2 = new Velocity(-1.0, 0.0);

        // Compute post-collision velocities
        Velocity[] result = ElasticCollision2D.compute(m1, v1, m2, v2);
        System.out.println("After collision:");
        System.out.printf("Body 1 → (%.2f, %.2f) m/s%n", result[0].vx, result[0].vy);
        System.out.printf("Body 2 → (%.2f, %.2f) m/s%n", result[1].vx, result[1].vy);
    }
}

```

## Summary

- TheAlgorithms/Java provides a complete **physics simulation algorithms** suite in `src/main/java/com/thealgorithms/physics/`
- **Runge-Kutta 4th-order** integration powers the nonlinear pendulum simulator (`SimplePendulumRK4`)
- **Analytical solvers** handle projectile motion (`ProjectileMotion`), damped oscillators (`DampedOscillator`), and elastic collisions (`ElasticCollision2D`)
- **Fundamental law implementations** include Coulomb's law, gravitation, Snell's law, and thin-lens optics
- All classes are **stateless and thread-safe**, designed for immediate use in educational or production Java applications

## Frequently Asked Questions

### What numerical integration method does the pendulum simulator use?

The `SimplePendulumRK4` class implements the **4th-order Runge-Kutta (RK4)** method as defined in [`SimplePendulumRK4.java`](https://github.com/TheAlgorithms/Java/blob/main/SimplePendulumRK4.java). This explicit integrator provides high accuracy for nonlinear differential equations governing pendulum motion.

### Can these physics algorithms handle real-time game engine requirements?

While the algorithms are mathematically correct and stateless, they are designed for educational clarity rather than optimized real-time performance. The RK4 integrator and collision solvers can serve as reference implementations, but game engines may require additional spatial partitioning or vectorization for high-frequency physics ticks.

### How do I calculate projectile motion when the launch and landing heights differ?

Use the `ProjectileMotion.calculateTrajectory()` method as implemented in [`ProjectileMotion.java`](https://github.com/TheAlgorithms/Java/blob/main/ProjectileMotion.java). Pass the initial velocity, launch angle, and initial height as parameters; the method returns a `Result` object containing time of flight, horizontal range, and maximum height calculated via analytic kinematic equations.

### Are unit tests available for the physics simulation algorithms?

Yes. The repository includes JUnit test suites such as `SimplePendulumRK4Test` that validate the numerical accuracy of the integrators and the correctness of the physics formulas against known analytical solutions.