mirror of
https://github.com/TheAlgorithms/Java.git
synced 2026-03-13 08:40:43 +08:00
81 lines
3.3 KiB
Java
81 lines
3.3 KiB
Java
package com.thealgorithms.physics;
|
|
|
|
/**
|
|
* Implements Coulomb's Law for electrostatics.
|
|
* Provides simple static methods to calculate electrostatic force and circular orbit velocity.
|
|
*
|
|
* @author [Priyanshu Singh](https://github.com/Priyanshu1303d)
|
|
* @see <a href="https://en.wikipedia.org/wiki/Coulomb%27s_law">Wikipedia</a>
|
|
*/
|
|
public final class CoulombsLaw {
|
|
|
|
/** Coulomb's constant in N·m²/C² */
|
|
public static final double COULOMBS_CONSTANT = 8.9875517923e9;
|
|
|
|
/**
|
|
* Private constructor to prevent instantiation of this utility class.
|
|
*/
|
|
private CoulombsLaw() {
|
|
}
|
|
|
|
/**
|
|
* Calculates the electrostatic force vector exerted by one charge on another.
|
|
* The returned vector is the force *on* the second charge (q2).
|
|
*
|
|
* @param q1 Charge of the first particle (in Coulombs).
|
|
* @param x1 X-position of the first particle (m).
|
|
* @param y1 Y-position of the first particle (m).
|
|
* @param q2 Charge of the second particle (in Coulombs).
|
|
* @param x2 X-position of the second particle (m).
|
|
* @param y2 Y-position of the second particle (m).
|
|
* @return A double array `[fx, fy]` representing the force vector on the second charge.
|
|
*/
|
|
public static double[] calculateForceVector(double q1, double x1, double y1, double q2, double x2, double y2) {
|
|
// Vector from 1 to 2
|
|
double dx = x2 - x1;
|
|
double dy = y2 - y1;
|
|
double distanceSq = dx * dx + dy * dy;
|
|
|
|
// If particles are at the same position, force is zero to avoid division by zero.
|
|
if (distanceSq == 0) {
|
|
return new double[] {0, 0};
|
|
}
|
|
|
|
double distance = Math.sqrt(distanceSq);
|
|
// Force magnitude: k * (q1 * q2) / r^2
|
|
// A positive result is repulsive (pushes q2 away from q1).
|
|
// A negative result is attractive (pulls q2 toward q1).
|
|
double forceMagnitude = COULOMBS_CONSTANT * q1 * q2 / distanceSq;
|
|
|
|
// Calculate the components of the force vector
|
|
// (dx / distance) is the unit vector pointing from 1 to 2.
|
|
double fx = forceMagnitude * (dx / distance);
|
|
double fy = forceMagnitude * (dy / distance);
|
|
|
|
return new double[] {fx, fy};
|
|
}
|
|
|
|
/**
|
|
* Calculates the speed required for a stable circular orbit of a charged particle
|
|
* around a central charge (e.g., an electron orbiting a nucleus).
|
|
*
|
|
* @param centralCharge The charge of the central body (in Coulombs).
|
|
* @param orbitingCharge The charge of the orbiting body (in Coulombs).
|
|
* @param orbitingMass The mass of the orbiting body (in kg).
|
|
* @param radius The radius of the orbit (in m).
|
|
* @return The orbital speed (in m/s).
|
|
* @throws IllegalArgumentException if mass or radius are not positive.
|
|
*/
|
|
public static double calculateCircularOrbitVelocity(double centralCharge, double orbitingCharge, double orbitingMass, double radius) {
|
|
if (orbitingMass <= 0 || radius <= 0) {
|
|
throw new IllegalArgumentException("Orbiting mass and radius must be positive.");
|
|
}
|
|
|
|
// We only need the magnitude of the force, which is always positive.
|
|
double forceMagnitude = Math.abs(COULOMBS_CONSTANT * centralCharge * orbitingCharge) / (radius * radius);
|
|
|
|
// F_c = m * v^2 / r => v = sqrt(F_c * r / m)
|
|
return Math.sqrt(forceMagnitude * radius / orbitingMass);
|
|
}
|
|
}
|