# Rust physics Engine

## Enum of SI Units
Prevents misspelling and increases code readability

1. Metre
2. Second
3. Kilogram
4. Ampere
5. Kelvin
6. Mole
7. Candela

#### You can print them

``` rust
println!("An apple is aproximately 1 {}",SiUnit::Kilogram);
println!("A minute is aproximately 60 {}s",SiUnit::Second);
```

## The Value struct
Create a struct that holds an f64 and two vectors of SI Units one for the numerator and the other for the denominator

``` rust
let fast = Value{magnitude: 10_f64,si_units_num: Vec::from([SiUnit::Metre]),si_units_den: Vec::from([SiUnit::Second,SiUnit::Second])};
let slow = Value{magnitude: 2_f64,si_units_num: Vec::from([SiUnit::Metre]),si_units_den: Vec::from([SiUnit::Second,SiUnit::Second])};
```

### Add Values
``` rust
println!("{}",fast.clone()+slow.clone());
```

### Multiply values
Note the units change when preforming multiplication
``` rust
println!("{}",fast.clone() * slow.clone());
```

### We can also divide
``` rust
let distance = Value{magnitude: 20_f64,si_units_num: Vec::from([SiUnit::Metre]),si_units_den: Vec::<SiUnit>::new()};
let time = Value{magnitude: 2_f64,si_units_num: Vec::from([SiUnit::Second]),si_units_den: Vec::<SiUnit>::new()};

let speed = distance/time;

println!("Speed is {}",speed);
```
We get a Value representing speed without explicitly creating it.

## DerivedUnits and DerivedQuantities
Instead of declaring the whole Value each time, we can use Value templates from the builtin enums DerivedUnits and DerivedQuantities

Derived Units

1. Hertz
2. Newtons
3. Pascals
4. Joules
5. Watts
6. Volts
7. Coulombs
8. Sieverts

Derived Quantities

1. Speed
2. Velocity
3. Acceleration
4. Area
5. Volume
6. Mass
7. Force
8. Time
9. Scalar
10. Distance

### The get_value function
The get_value function returns a Value type, and the set_magnitude function changes the magnitude.
``` rust
let force = DerivedQuantities::Force.get_value().set_magnitude(15_f64);
let pressure = DerivedUnit::Pascals.get_value().set_magnitude(5_f64);

let area = force/pressure;

println!("{}",area);
```
### The same() function
We can also check if the Value we get is indeed an area by comapring it with the builtin Area template using the same() function

assert!(area.same(&DerivedQuantities::Area.get_value()));

## SI Constants
You can also use some of the built in physical constants
``` rust
let g =  SiConstant::GravitationalConstant.get_value();
let c = SiConstant::SpeedOfLight.get_value();

println!("Gravitational Constant is {}",g);
println!("Soeed of light is {}",c);
```
## Examples
We can derive earth's acceleration due to gravity using earth's mass, radius, and the gravitational constant.
g = Gm/(r^2) where g is the acceleration, G is the gravitational constant, m is the mass, r is the radius.
``` rust
let earth_mass = DerivedQuantities::Mass.get_value().set_magnitude(5.972e24);
let earth_radius = DerivedQuantities::Distance.get_value().set_magnitude(6371e3);
let g = SiConstant::GravitationalConstant.get_value();

let acc = g*earth_mass/earth_radius.powi(2);

assert!(acc.same(&DerivedQuantities::Acceleration.get_value()));

println!("{}",acc);
```
## Vectors
We can also represent physical vectors that contain direction
``` rust
let v = Vector{value: DerivedQuantities::Force.get_value(),theta: PI};
println!("{}",v);
```
### We can add Vectors 
``` rust
let car1 = Vector{value: DerivedQuantities::Force.get_value(),theta: 0_f64};
let car2 = Vector{value: DerivedQuantities::Force.get_value(),theta: PI/2.0};
let collision = car1+car2;
println!("{}",collision);
```
### We can multiply
``` rust
let v1 = Vector{value: DerivedQuantities::Force.get_value(),theta: 0_f64};
let v2 = Vector{value: DerivedQuantities::Force.get_value(),theta: PI/2.0};
let product = v1*v2;
println!("{}",product);
```