formulas.h

Go to the documentation of this file.

 
#pragma once
#include <SI/constants.h>
#define FUNC [[nodiscard]] inline
 
namespace SI { namespace formula {
 
    // 1. 2D Formulas
    // --------------
    FUNC length hypotenuse_of_triangle(const length a, const length b)
    {
        return sqrt(a*a + b*b);
    }

    FUNC angle angle1_in_triangle(const length o, const length h)
    {
        return radians(asin(o / h));
    }

    FUNC angle angle2_in_triangle(const length a, const length h)
    {
        return radians(acos(a / h));
    }

    FUNC angle angle3_in_triangle(const length a, const length o)
    {
        return radians(atan(o / a));
    }

    FUNC area area_of_triangle(const length b, const length h)
    {
        return 0.5 * b * h;
    }

    FUNC length perimeter_of_rectangle(const length l, const length b)
    {
        return 2. * (l + b);
    }

    FUNC area area_of_rectangle(const length l, const length b)
    {
        return l * b;
    }

    FUNC length perimeter_of_square(const length a)
    {
        return 4. * a;
    }

    FUNC area area_of_square(const length a)
    {
        return a * a;
    }

    FUNC area area_of_trapezoid(const length b1, const length b2, const length h)
    {
        return 0.5 * (b1 + b2) * h;
    }

    FUNC length circumference_of_circle(const length r)
    {
        return constant::tau * r;
    }

    FUNC length radius_of_circumference(const length c)
    {
        return c / constant::tau;
    }

    FUNC area area_of_circle(const length r)
    {
        return constant::pi * r * r;
    }

    FUNC length perimeter_of_ellipse(const length a, const length b)
    {
        return constant::pi * sqrt(2.0 * (square(a) + square(b)));
    }

    FUNC area area_of_ellipse(const length a, const length b)
    {
        return constant::pi * a * b;
    }

    FUNC dimensionless eccentricity_of_ellipse(const length a, const length b)
    {
        return std::sqrt(1.0 - (square(b) / square(a)));
    }

    FUNC length latus_rectum_of_ellipse(const length a, const length b)
    {
        return 2.0 * square(b) / a;
    }

    FUNC length distance(const length x1, const length y1, const length x2, const length y2)
    {
        const length dx = x2 - x1;
        const length dy = y2 - y1;
        return sqrt((dx * dx) + (dy * dy));
    }
 
    // 2. 3D Formulas
    // --------------
    FUNC area area_of_cube(const length a)
    {
        return 6. * a * a;
    }

    FUNC volume volume_of_cube(const length a)
    {
        return a * a * a;
    }

    FUNC area area_of_cylinder(const length r, const length h)
    {
        return constant::tau * r * (r + h);
    }

    FUNC volume volume_of_cylinder(const length r, const length h)
    {
        return constant::pi * square(r) * h;
    }

    FUNC area area_of_cone(const length r, const length h)
    {
        return constant::pi * r * (r + h);
    }

    FUNC volume volume_of_cone(const length r, const length h)
    {
        return (1./3.) * constant::pi * square(r) * h;
    }

    FUNC area area_of_sphere(const length r)
    {
        return 4. * constant::pi * square(r);
    }

    FUNC volume volume_of_sphere(const length r)
    {
        return (4. / 3.) * constant::pi * r * r * r;
    }

    FUNC volume volume_of_prism(const area A, const length h)
    {
        return A * h;
    }
 
    // 3. Moving Objects
    // -----------------
    FUNC velocity average_speed(const length distance, const time duration)
    {
        return distance / duration;
    }

    FUNC energy kinetic_energy(const mass m, const velocity v)
    {
        return 0.5 * m * square(v);
    }

    FUNC time time_of_free_fall(const length height, const acceleration gravity)
    {
        return sqrt((2. * height) / gravity);
    }

    FUNC length braking_distance(const velocity v0, const velocity v1, const acceleration deceleration)
    {
        return (square(v0) - square(v1)) / (2.0 * deceleration);
    }

    FUNC acceleration acceleration_for_distance(const velocity v0, const velocity v1, const length distance)
    {
        return (square(v1) - square(v0)) / (2.0 * distance);
    }

    FUNC velocity final_velocity(const velocity i, const acceleration a, const SI::time t)
    {
        return i + a * t;
    }

    FUNC acceleration acceleration_of(const velocity delta_v, const SI::time delta_t)
    {
        return delta_v / delta_t;
    }
 
    // 4. Vehicle Formulas
    // -------------------
    FUNC dimensionless wheel_rpm(const velocity v, const length r)
    {
        return v / (constant::tau * r) * 60_s;
    }

    FUNC velocity wheel_speed(const length r, const dimensionless RPM)
    {
        return constant::tau * r * (RPM / 60_s);
    }

    FUNC length turning_radius_of_vehicle(const length wheelbase, const angle steering_angle, const length tire_width)
    {
        return wheelbase / sin(steering_angle) + tire_width / 2.0;
    }

    FUNC dimensionless g_force_of_acceleration(const velocity v0, const velocity v1, const time t)
    {
        return (v1 - v0) / (t * constant::Earth_gravity);
    }
 
    // 5. Aircraft Formulas
    // --------------------
    FUNC velocity true_airspeed(const force lift_force, const dimensionless lift_coefficient, const area wing_surface, const density air_density)
    {
        return sqrt((2.0 * lift_force) / (lift_coefficient * wing_surface * air_density));
    }

    FUNC force lift_force_of_wing(const dimensionless lift_coefficient, const area wing_surface, const density air_density, const velocity true_air_speed)
    {
        return 0.5 * air_density * square(true_air_speed) * wing_surface * lift_coefficient;
    }

    FUNC dimensionless Mach_number(const velocity v, const velocity speed_of_sound)
    {
        return v / speed_of_sound;
    }

    FUNC angle glide_path(const length h, const length v)
    {
        return atan2(v, h);
    }

    FUNC dimensionless glide_ratio(const length h, const length a)
    {
        return h / a;
    }

    FUNC length vertical_height(const angle glide_path, const length horizontal_distance)
    {
        return horizontal_distance * tan(glide_path);
    }

    FUNC velocity climb_rate(const velocity ground_speed, const angle climb_angle)
    {
        return sin(climb_angle) * ground_speed;
    }

    FUNC length turn_radius(const velocity ground_speed, const angle bank_angle)
    {
        return (ground_speed * ground_speed) / (constant::Earth_gravity * tan(bank_angle));
    }
 
    // 6. Formulas for Gravitation
    // ---------------------------
    FUNC energy gravitational_potential_energy(const mass m, const length h, const acceleration gravity)
    {
        return m * h * gravity;
    }

    FUNC force gravitational_attractive_force(const mass m1, const mass m2, const length d)
    {
        return (constant::G * m1 * m2) / square(d);
    }

    FUNC velocity gravitational_escape_velocity(const mass M, const length r)
    {
        return sqrt((2.0 * constant::G * M) / r);
    }

    FUNC dimensionless flattening_factor(const length Re, const length Rp)
    {
        return (Re - Rp) / Re;
    }

    FUNC acceleration local_gravity(const angle lat, const length h)
    {
        auto IGF = 9.780327_m_per_s² * (1.0 + 0.0053024 * sin2(lat) - 0.0000058 * sin2(2.0 * lat)); // International Gravity Formula
        auto FAC = -3.086e-6_m_per_s² * meters(h); // Free Air Correction
        return IGF + FAC;
    }

    FUNC length Schwarzschild_radius(const mass M)
    {
        return (2.0 * constant::G * M) / square(constant::c);
    }
 
    // 7. Various Formulas
    // -------------------
    FUNC length wavelength(const velocity v, const frequency f)
    {
        return v / f;
    }

    FUNC electric_potential sine_wave(const electric_potential V0, const frequency f, const SI::time t)
    {
        return V0 * sin(constant::tau * f * t);
    }

    FUNC velocity speed_of_sound_in_air(const temperature T)
    {
        double adiabatic_index = 1.4; // for air
        auto M = 0.0289645_kg_per_mol; // molar mass of the gas
        return sqrt((adiabatic_index * constant::R * T) / M);
    }

    FUNC force drag_in_fluid(const density p, const velocity u, const dimensionless cd, const area A)
    {
        return 0.5 * p * (u * u) * cd * A;
    }

    FUNC frequency frequency_of_chromatic_note(const int note, const int reference_note, const frequency reference_frequency)
    {
        return std::pow(std::pow(2., 1. / 12.), note - reference_note) * reference_frequency;
    }
 
    FUNC auto Newtons_motion(const length s0, const velocity v0, const acceleration a, const time t)
    {
        return s0 + v0 * t + 0.5 * a * t * t;
    }

    FUNC auto Lorentz_force(const double q, const velocity v, const double B)
    {
        return q * v * B;
    }

    FUNC temperature windchill_temperature(const temperature air_temperature, const velocity wind_speed)
    {
        auto air_celsius = celsius(air_temperature);
        return celsius(13.12 + 0.6215 * air_celsius
          + (0.3965 * air_celsius - 11.37) * std::pow(wind_speed / 1_km_per_h, 0.16));
    }

    FUNC temperature temperature_gradient(const length altitude)
    {
        if (altitude <= 11_km)
            return -6.5_K;
        if (altitude <= 20_km)
            return 0_K;
        if (altitude <= 32_km)
            return 1_K;
        if (altitude <= 37_km)
            return 2.8_K;
        if (altitude <= 51_km)
            return 0_K;
        if (altitude <= 71_km)
            return -2.8_K;
        return -2_K;
    }

    FUNC density density_of_dry_air(const pressure air_pressure, const temperature air_temperature)
    {
        return air_pressure / (constant::R_dry_air * air_temperature);
    }

    FUNC density density_of(const mass m, const volume V)
    {
        return m / V;
    }

    FUNC mass mass_of(const density p, const volume V)
    {
        return p * V;
    }

    FUNC volume volume_of(const mass m, const density p)
    {
        return m / p;
    }

    FUNC dimensionless BMI(const mass w, const length h)
    {
        return (w / square(h)) / 1_kg_per_m²;
    }

    FUNC auto consumed_electrical_power(const electric_current I, const electric_potential U)
    {
        return I * U;
    }

    FUNC auto sound_intensity(const power power_of_sound_source, const length distance_from_sound_source)
    {
        return power_of_sound_source / (4.0 * constant::pi * square(distance_from_sound_source));
    }

    FUNC length ballistic_max_height(const velocity v0, const length h, const angle a, const acceleration g)
    {
        return h + square(v0 * sin(a)) / (2.0 * g);
    }

    FUNC length ballistic_max_range(const velocity v0, const length h, const angle a, const acceleration g)
    {
        return ((v0 * sin(a) + sqrt(square(v0 * sin(a)) + 2.0 * g * h)) / g) * cos(a) * v0;
    }

    FUNC time ballistic_travel_time(const velocity v0, const length h, const angle a, const acceleration g)
    {
        return (v0 * sin(a) + sqrt(square(v0 * sin(a)) + 2.0 * g * h)) / g;
    }

    FUNC specific_energy absorbed_dose(const energy E, const mass m)
    {
        return E / m;
    }

    FUNC velocity min_of_array(velocity arr[], int n)
    {
        if (n < 1)
            return meters_per_second(0);
        velocity minimum = arr[0];
        for (int i = 1; i < n; ++i)
            if (arr[i] < minimum)
                minimum = arr[i];
        return minimum;
    }

    FUNC velocity max_of_array(velocity arr[], int n)
    {
        if (n < 1)
            return meters_per_second(0);
        velocity maximum = arr[0];
        for (int i = 1; i < n; ++i)
            if (arr[i] > maximum)
                maximum = arr[i];
        return maximum;
    }

    FUNC velocity avg_of_array(velocity arr[], int n)
    {
        if (n < 1)
            return meters_per_second(0);
        velocity sum = meters_per_second(0);
        for (int i = 0; i < n; ++i)
            sum += arr[i];
        return sum / n;
    }

    FUNC velocity sum_of_array(velocity arr[], int n)
    {
        velocity sum = meters_per_second(0);
        for (int i = 0; i < n; ++i)
            sum += arr[i];
        return sum;
    }

    FUNC length distance_on_Earth(angle lat1, angle long1, angle lat2, angle long2)
    {
        angle dLat = lat1 - lat2;    // difference in latitude
        angle dLong = long1 - long2; // difference in longitude
 
        angle a = sin2(dLat / 2.) + cos(lat1) * cos(lat2) * sin2(dLong / 2.); // Haversine intermediate
        auto  c = 2. * atan2(sqrt(a), sqrt(1. - a)); // central angle 
 
        return c * 6371.0088_km; // mean Earth radius, recommended by NOAA
    }
 
    // 8. References
    // -------------
    // 1. https://en.wikipedia.org/wiki/Turning_radius
    // 2. https://en.wikipedia.org/wiki/Lift_(force)
    // 3. https://en.wikipedia.org/wiki/Wavelength
    // 4. https://en.wikipedia.org/wiki/Lorentz_force
    // 5. https://de.wikipedia.org/wiki/Windchill
    // 6. https://en.wikipedia.org/wiki/Density_of_air
    // 7. https://physics.info/equations/
    // 8. https://www.vcalc.com/wiki/ballistic-max-height
    // 9. https://www.vcalc.com/wiki/ballistic-range
    // 10. https://www.vcalc.com/wiki/ballistic-travel-time
    // 11. https://best-calculators.com/tools/latitude-longitude-distance-calculator/
 
} } // end of namespace SI::formula
 
#undef FUNC