Converting Geographic Coordinates into Lambert2008 coordinates

Since the code is about implementing mathematical formulas I would make an exception and completely ignore the usual naming conventions. Instead, I would use the exact symbols as that document.

This would mean a little bit copy/paste because it's difficult to write symbols like [ϕ, λ, θ] but the compiler can work with unicode.

I find that code like this:

var rad = 0.01745329252;

var ellipsoide = (a: 6378137, f: 1 / 298.257222101);
var ϕ1 = 49.8333333 * rad;
var ϕ2 = 51.1666667 * rad;
var ϕ0 = 50.797815 * rad;
var λ0 = 4.359215833 * rad;
var x0 = 649328;
var y0 = 665262;

is the most easy one to understand because you can compare it with the book almost without any translation.

• In math heavy code you might use the using static directive, see the microsoft documentation such that System.Math. can be removed throughout the code.
• Excentricity can be made a constant and may have a shorter name as I have seen in other codes dealing with WGS84.
• If possible refer to a document and formula number in a comment
• Although sometime frowned on, I like to layout the the code as much as possible as the mathematical equation looks like. (use extra parentheses if it improves readability)

With this in mind I came to to following example for method T.

using static System.Math;

public const double E2 = (2 * f) - (f * f);  # Excentricity squared
public const double E1 = Sqrt(E2);           # Excentricity

.....

    static double T(double lat)
    {
        // if possible refer to a document and formula number
        return  Tan(PI / 4 - lat / 2) 
                / 
                Pow( ((1 - E1 * Sin(lat)) 
                      / 
                      (1 + E1 * Sin(lat))) , E1 / 2);
    }

Constants

You have a lot of mathematical constants that aren't constants in your API. Why?

Excentricity, MLower, MUpper, TLower, TUpper, TOrigin, ROrigin, N, G.

EDIT:

In the comments you suggest that the compiler does not accept these constants. But the problem is not the compiler, it's that you should not use the formula to declare a constant. Pre-calculate the constant using T4 and use the result in your derived constants.

// Just paste the pre-calculated result from T4
static double Excentricity = 0.0818191910428158d;

A simpler option is to use static readonlyas Peter suggests in his answer.

Naming Conventions

Some, but not all of your variables and functions are named after mathematical usage. I like it either way, but a combination is an inconsistent naming convention.

public const double f = 1 / 298.257222101;
public const double lowerLatitude = 49.8333333 * Mathf.Deg2Rad;

Aliases

You are using both System.Math and UnityEngine.Mathf. To avoid repeating code I suggest to import the one you used most as a static using and the other as an aliased using.

using static UnityEngine.Mathf;
using Math = System.Math;

First thank you all for your help, and specifically @t3chb0t , @JanKuiken , @PeterTaylor and @dfhwze . I learned a lot today.

Here is the refactored code taking into account all the comments. I think it looks a lot better already.

Not only that but performance was multiplied by 20

using static System.Math;
using UnityEngine;

public static class Lambert2008
{
    public const int a = 6378137;
    public const double f = 1 / 298.257222101;
    public const double rad = PI/180;
    public const double ϕ1 = 49.8333333 * rad;
    public const double ϕ2 = 51.1666667 * rad;
    public const double ϕ0 = 50.797815 * rad;
    public const double λ0 = 4.359215833 * rad;
    public const int x0 = 649328;
    public const int y0 = 665262;

    static readonly double E = Sqrt((2 - f) * f);

    static readonly double M1;
    static readonly double M2;

    static readonly double T1;
    static readonly double T2;
    static readonly double T0;

    static readonly double N;
    static readonly double G;
    static readonly double R0;

    static Lambert2008()
    {
        double _;
        (_, T0) = MT(ϕ0);
        (M1, T1) = MT(ϕ1);
        (M2, T2) = MT(ϕ2);

        N = Log(M1 / M2, T1 / T2);
        G = M1 / (N * Pow(T1, N));
        R0 = a * G * Pow(T0, N);
    }

    static (double, double) MT(double ϕ)
    {
        var e_sinϕ = E * Sin(ϕ);
        var m = Cos(ϕ) / Sqrt(1 - Pow(e_sinϕ, 2));
        var t = CalculateT(ϕ);
        return (m, t);
    }

    static double R(double t)
    {
        return a * G * Pow(t, N);
    }

    static double CalculateT(double ϕ)
    {
        var e_sinϕ = E * Sin(ϕ);
        return Tan(PI / 4 - ϕ / 2)
            / Pow((1 - e_sinϕ) / (1 + e_sinϕ), E / 2);
    }

    public static Vector2 FromGeographicRelative(Vector2 coordinates)
    {
        double _, t, r;
        (_, t) = MT(coordinates.x * rad);
        r = R(t);
        var θ = N * (coordinates.y * rad - λ0);
        var res = new Vector2
        {
            x = (float)(r * Sin(θ)),
            y = (float)(R0 - r * Cos(θ))
        };
        return res;
    }

    public static Vector2 FromGeographic(Vector2 coordinates)
    {
        return FromGeographicRelative(coordinates) + new Vector2(x0, y0);
    }
}