C# Online Compiler | .NET Fiddle

<no name> by Anonymous

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#

var measurements = new (string, string[], string[])[]
{
	// Measurement Type Definitions (start) ------------------------------------------------

	("Length", new string[] { "Length" }, new string[] { }),
	("Time", new string[] { "Time" }, new string[] { }),
	("Mass", new string[] { "Mass" }, new string[] { }),
	("Angle", new string[] { "Angle" }, new string[] { }),
	("Tempurature", new string[] { "Tempurature" }, new string[] { }),
	("ElectricCharge", new string[] { "ElectricCharge" }, new string[] { }),

	("Speed", new string[] { "Length", }, new string[] { "Time", }),
	("Acceleration", new string[] { "Length", }, new string[] { "Time", "Time", }),
	("Force", new string[] { "Mass", "Length", }, new string[] { "Time", "Time", }),
	("MassFlow", new string[] { "Mass", }, new string[] { "Time", }),
	("MassFlowAcceleration", new string[] { "Mass", }, new string[] { "Time", "Time", }),
	("TimeSpace", new string[] { "Time", "Time", }, new string[] { }),
	("LinearMass", new string[] { "Mass", "Length", }, new string[] { }),

	// Measurement Type Definitions (end) --------------------------------------------------
};

var viewStrings = measurements.Select(x => string.Join("*", x.Item2) + (x.Item3.Length > 0 ? "/" + string.Join("/", x.Item3) : string.Empty)).ToArray();
var measurementsFormatted = measurements.Select(x => (x.Item1, x.Item2.Clone() as string[], x.Item3.Clone() as string[])).ToArray();
Array.ForEach(measurementsFormatted, x => { Array.Sort(x.Item2); Array.Sort(x.Item3); });
var keys = measurementsFormatted.Select(x => string.Join("*", x.Item2) + (x.Item3.Length > 0 ? "/" + string.Join("/", x.Item3) : string.Empty)).ToArray();
//var dictionary = keys

#>
//------------------------------------------------------------------------------
// <auto-generated>
//	  This code was generated from the "MeasurementTypes.tt" T4 Text Template.
// </auto-generated>
//------------------------------------------------------------------------------

// Measurement Definitions:
//
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
//    <#= measurement.Item1 #>: <#= viewStrings[measurementIndex] #>
<# measurementIndex++; } } #>

using System;

namespace Measurements
{
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
<# bool isBaseUnit = measurement.Item2.Length + measurement.Item3.Length == 1; #>
<# bool isDerivedUnit = !isBaseUnit; #>
<# var concatenatedBaseUnits = measurement.Item2.Concat(measurement.Item3); #>
	#region <#= measurement.Item1 #>

	public struct <#= measurement.Item1 #><T>
	{
<# if (isBaseUnit) { #>
		internal static Func<T, T>[][] Table = UnitConversionTable.Build<<#= measurement.Item1 #>.Units, T>();
<# } #>
		internal T _measurement;
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
		internal <#= baseUnit #>.Units _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>;
<# baseUnitIndex++; } } #>

<# //------------------------------------------------------------------------------------------- #>
		#region Constructors

		public <#= measurement.Item1 #>(T measurement, MeasurementUnitsSyntaxTypes.<#= measurement.Item1 #>Units units) : this(measurement
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
			, units._<#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
			) { }

<# if (isDerivedUnit) { #>
		public <#= measurement.Item1 #>(T measurement, <#= measurement.Item1 #>.Units units)
		{
			throw new NotImplementedException();
		}
<# } #>

		public <#= measurement.Item1 #>(T measurement
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
			, <#= baseUnit #>.Units <#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
			)
		{
			throw new NotImplementedException();
		}

		#endregion

<# //------------------------------------------------------------------------------------------- #>
		#region Properties

<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
        public <#= baseUnit #>.Units <#= baseUnit #>Units<#= baseUnitIndex + 1 #>
        {
            get { return _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>; }
            set
            {
                if (value != _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>)
                {
<# { int temp = 0; #>
                    _measurement = this[<#= string.Join(", ", concatenatedBaseUnits.Select(x => baseUnitIndex + 1 == ++temp ? "value" : "_" + x + "Units" + temp)) #>];
<# } #>
                    _<#= baseUnit #>Units<#= baseUnitIndex + 1 #> = value;
                }
            }
        }

<# baseUnitIndex++; } } #>
		public T this[MeasurementUnitsSyntaxTypes.<#= measurement.Item1 #>Units units]
		{
<# { int temp = 0; #>
			get { return this[<#= string.Join(", ", concatenatedBaseUnits.Select(x => "units._" + x + "Units" + ++temp)) #>]; }
<# } #>
		}

<# { int temp = 0; #>
		public T this[<#= string.Join(", ", concatenatedBaseUnits.Select(x => x + ".Units" + " " + x + "Units" + ++temp)) #>]
<# } #>
        {
            get
            {
                T measurement = _measurement;
<# { int baseUnitIndex = 0; foreach (var numerator in measurement.Item2) { #>
                if (<#= numerator #>Units<#= baseUnitIndex + 1 #> != _<#= numerator #>Units<#= baseUnitIndex + 1 #>)
                {
                    if (<#= numerator #>Units<#= baseUnitIndex + 1 #> < _<#= numerator #>Units<#= baseUnitIndex + 1 #>)
                    {
                        measurement = <#= numerator #><T>.Table[(int)_<#= numerator #>Units<#= baseUnitIndex + 1 #>][(int)<#= numerator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                    else
                    {
                        measurement = <#= numerator #><T>.Table[(int)<#= numerator #>Units<#= baseUnitIndex + 1 #>][(int)_<#= numerator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                }
<# baseUnitIndex++; } #>
<# foreach (var denominator in measurement.Item3) { #>
                if (<#= denominator #>Units<#= baseUnitIndex + 1 #> != _<#= denominator #>Units<#= baseUnitIndex + 1 #>)
                {
                    if (<#= denominator #>Units<#= baseUnitIndex + 1 #> > _<#= denominator #>Units<#= baseUnitIndex + 1 #>)
                    {
                        measurement = <#= denominator #><T>.Table[(int)_<#= denominator #>Units<#= baseUnitIndex + 1 #>][(int)<#= denominator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                    else
                    {
                        measurement = <#= denominator #><T>.Table[(int)<#= denominator #>Units<#= baseUnitIndex + 1 #>][(int)_<#= denominator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                }
<# baseUnitIndex++; } #>
<# } #>
                return measurement;
            }
        }


		#endregion

<# //------------------------------------------------------------------------------------------- #>
		#region Overrides

		public override bool Equals(object obj)
        {
            if (obj is <#= measurement.Item1 #><T>)
            {
                return this == (<#= measurement.Item1 #><T>)obj;
            }
            return false;
        }

		#endregion
	}

	#endregion

<# measurementIndex++; } } #>

<# //------------------------------------------------------------------------------------------- #>
	#region MeasurementUnitsSyntaxTypes

	public static class MeasurementUnitsSyntaxTypes
	{
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
<# var concatenatedBaseUnits = measurement.Item2.Concat(measurement.Item3); #>
		public struct <#= measurement.Item1 #>Units
		{
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
			public <#= baseUnit #>.Units _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>;
<# baseUnitIndex++; } } #>

			//public static implicit operator <#= measurement.Item1 #>Units(<#= measurement.Item1 #>.Units units)
            //{
            //    <#= measurement.Item1 #>Units convertedUnits = new <#= measurement.Item1 #>Units();
            //    <#= measurement.Item1 #>.Map(units
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
			//		, out convertedUnits.<#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
			//		);
            //    return convertedUnits;
            //}
		}
<# measurementIndex++; } } #>
	}

	#endregion

<# //------------------------------------------------------------------------------------------- #>
	#region Units

<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
<# var concatenatedBaseUnits = measurement.Item2.Concat(measurement.Item3); #>
	#region <#= measurement.Item1 #> Units

	public static class <#= measurement.Item1 #>
	{
		public enum Units
		{
			// none
		}

		public static void Map<T>(
			T measurement,
			<#= measurement.Item1 #>.Units units
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
			, out <#= baseUnit #>.Units <#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
			)
		{
			throw new NotImplementedException();
		}
	}

	#endregion

<# measurementIndex++; } } #>

	#endregion
}

​x
 
<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
​
var measurements = new (string, string[], string[])[]
{
    // Measurement Type Definitions (start) ------------------------------------------------
​
    ("Length", new string[] { "Length" }, new string[] { }),
    ("Time", new string[] { "Time" }, new string[] { }),
    ("Mass", new string[] { "Mass" }, new string[] { }),
    ("Angle", new string[] { "Angle" }, new string[] { }),
    ("Tempurature", new string[] { "Tempurature" }, new string[] { }),
    ("ElectricCharge", new string[] { "ElectricCharge" }, new string[] { }),
​
    ("Speed", new string[] { "Length", }, new string[] { "Time", }),
    ("Acceleration", new string[] { "Length", }, new string[] { "Time", "Time", }),
    ("Force", new string[] { "Mass", "Length", }, new string[] { "Time", "Time", }),
    ("MassFlow", new string[] { "Mass", }, new string[] { "Time", }),
    ("MassFlowAcceleration", new string[] { "Mass", }, new string[] { "Time", "Time", }),
    ("TimeSpace", new string[] { "Time", "Time", }, new string[] { }),
    ("LinearMass", new string[] { "Mass", "Length", }, new string[] { }),
​
    // Measurement Type Definitions (end) --------------------------------------------------
};
​
var viewStrings = measurements.Select(x => string.Join("*", x.Item2) + (x.Item3.Length > 0 ? "/" + string.Join("/", x.Item3) : string.Empty)).ToArray();
var measurementsFormatted = measurements.Select(x => (x.Item1, x.Item2.Clone() as string[], x.Item3.Clone() as string[])).ToArray();
Array.ForEach(measurementsFormatted, x => { Array.Sort(x.Item2); Array.Sort(x.Item3); });
var keys = measurementsFormatted.Select(x => string.Join("*", x.Item2) + (x.Item3.Length > 0 ? "/" + string.Join("/", x.Item3) : string.Empty)).ToArray();
//var dictionary = keys
​
#>
//------------------------------------------------------------------------------
// <auto-generated>
//    This code was generated from the "MeasurementTypes.tt" T4 Text Template.
// </auto-generated>
//------------------------------------------------------------------------------
​
// Measurement Definitions:
//
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
//    <#= measurement.Item1 #>: <#= viewStrings[measurementIndex] #>
<# measurementIndex++; } } #>
​
using System;
​
namespace Measurements
{
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
<# bool isBaseUnit = measurement.Item2.Length + measurement.Item3.Length == 1; #>
<# bool isDerivedUnit = !isBaseUnit; #>
<# var concatenatedBaseUnits = measurement.Item2.Concat(measurement.Item3); #>
    #region <#= measurement.Item1 #>
​
    public struct <#= measurement.Item1 #><T>
    {
<# if (isBaseUnit) { #>
        internal static Func<T, T>[][] Table = UnitConversionTable.Build<<#= measurement.Item1 #>.Units, T>();
<# } #>
        internal T _measurement;
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
        internal <#= baseUnit #>.Units _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>;
<# baseUnitIndex++; } } #>
​
<# //------------------------------------------------------------------------------------------- #>
        #region Constructors
​
        public <#= measurement.Item1 #>(T measurement, MeasurementUnitsSyntaxTypes.<#= measurement.Item1 #>Units units) : this(measurement
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
            , units._<#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
            ) { }
​
<# if (isDerivedUnit) { #>
        public <#= measurement.Item1 #>(T measurement, <#= measurement.Item1 #>.Units units)
        {
            throw new NotImplementedException();
        }
<# } #>
​
        public <#= measurement.Item1 #>(T measurement
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
            , <#= baseUnit #>.Units <#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
            )
        {
            throw new NotImplementedException();
        }
​
        #endregion
​
<# //------------------------------------------------------------------------------------------- #>
        #region Properties
​
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
        public <#= baseUnit #>.Units <#= baseUnit #>Units<#= baseUnitIndex + 1 #>
        {
            get { return _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>; }
            set
            {
                if (value != _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>)
                {
<# { int temp = 0; #>
                    _measurement = this[<#= string.Join(", ", concatenatedBaseUnits.Select(x => baseUnitIndex + 1 == ++temp ? "value" : "_" + x + "Units" + temp)) #>];
<# } #>
                    _<#= baseUnit #>Units<#= baseUnitIndex + 1 #> = value;
                }
            }
        }
​
<# baseUnitIndex++; } } #>
        public T this[MeasurementUnitsSyntaxTypes.<#= measurement.Item1 #>Units units]
        {
<# { int temp = 0; #>
            get { return this[<#= string.Join(", ", concatenatedBaseUnits.Select(x => "units._" + x + "Units" + ++temp)) #>]; }
<# } #>
        }
​
<# { int temp = 0; #>
        public T this[<#= string.Join(", ", concatenatedBaseUnits.Select(x => x + ".Units" + " " + x + "Units" + ++temp)) #>]
<# } #>
        {
            get
            {
                T measurement = _measurement;
<# { int baseUnitIndex = 0; foreach (var numerator in measurement.Item2) { #>
                if (<#= numerator #>Units<#= baseUnitIndex + 1 #> != _<#= numerator #>Units<#= baseUnitIndex + 1 #>)
                {
                    if (<#= numerator #>Units<#= baseUnitIndex + 1 #> < _<#= numerator #>Units<#= baseUnitIndex + 1 #>)
                    {
                        measurement = <#= numerator #><T>.Table[(int)_<#= numerator #>Units<#= baseUnitIndex + 1 #>][(int)<#= numerator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                    else
                    {
                        measurement = <#= numerator #><T>.Table[(int)<#= numerator #>Units<#= baseUnitIndex + 1 #>][(int)_<#= numerator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                }
<# baseUnitIndex++; } #>
<# foreach (var denominator in measurement.Item3) { #>
                if (<#= denominator #>Units<#= baseUnitIndex + 1 #> != _<#= denominator #>Units<#= baseUnitIndex + 1 #>)
                {
                    if (<#= denominator #>Units<#= baseUnitIndex + 1 #> > _<#= denominator #>Units<#= baseUnitIndex + 1 #>)
                    {
                        measurement = <#= denominator #><T>.Table[(int)_<#= denominator #>Units<#= baseUnitIndex + 1 #>][(int)<#= denominator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                    else
                    {
                        measurement = <#= denominator #><T>.Table[(int)<#= denominator #>Units<#= baseUnitIndex + 1 #>][(int)_<#= denominator #>Units<#= baseUnitIndex + 1 #>](measurement);
                    }
                }
<# baseUnitIndex++; } #>
<# } #>
                return measurement;
            }
        }
​
​
        #endregion
​
<# //------------------------------------------------------------------------------------------- #>
        #region Overrides
​
        public override bool Equals(object obj)
        {
            if (obj is <#= measurement.Item1 #><T>)
            {
                return this == (<#= measurement.Item1 #><T>)obj;
            }
            return false;
        }
​
        #endregion
    }
​
    #endregion
​
<# measurementIndex++; } } #>
​
<# //------------------------------------------------------------------------------------------- #>
    #region MeasurementUnitsSyntaxTypes
​
    public static class MeasurementUnitsSyntaxTypes
    {
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
<# var concatenatedBaseUnits = measurement.Item2.Concat(measurement.Item3); #>
        public struct <#= measurement.Item1 #>Units
        {
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
            public <#= baseUnit #>.Units _<#= baseUnit #>Units<#= baseUnitIndex + 1 #>;
<# baseUnitIndex++; } } #>
​
            //public static implicit operator <#= measurement.Item1 #>Units(<#= measurement.Item1 #>.Units units)
            //{
            //    <#= measurement.Item1 #>Units convertedUnits = new <#= measurement.Item1 #>Units();
            //    <#= measurement.Item1 #>.Map(units
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
            //      , out convertedUnits.<#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
            //      );
            //    return convertedUnits;
            //}
        }
<# measurementIndex++; } } #>
    }
​
    #endregion
​
<# //------------------------------------------------------------------------------------------- #>
    #region Units
​
<# { int measurementIndex = 0; foreach (var measurement in measurements) { #>
<# var concatenatedBaseUnits = measurement.Item2.Concat(measurement.Item3); #>
    #region <#= measurement.Item1 #> Units
​
    public static class <#= measurement.Item1 #>
    {
        public enum Units
        {
            // none
        }
​
        public static void Map<T>(
            T measurement,
            <#= measurement.Item1 #>.Units units
<# { int baseUnitIndex = 0; foreach (var baseUnit in concatenatedBaseUnits) { #>
            , out <#= baseUnit #>.Units <#= baseUnit #>Units<#= baseUnitIndex + 1 #>
<# baseUnitIndex++; } } #>
            )
        {
            throw new NotImplementedException();
        }
    }
​
    #endregion
​
<# measurementIndex++; } } #>
​
    #endregion
}

  Angle--------------------------------------

    angle1 = 90 Degrees
    angle2 = 0.5 Revolutions
    angle1 + angle2 = 270 Degrees
    angle2 - angle1 = 90 Degrees
    angle1 * 2 = 180 Degrees
    angle1 / 2 = 45 Degrees
    angle1 > angle2 = False
    angle1 == angle2 = False
    angle1 * 2 == angle2 = True
    angle1 != angle2 = True

  Length--------------------------------------

    length1 = 1 Meters
    length2 = 2 Yards
    length1 + length2 = 3.94 Yards
    length2 - length1 = 0.06000000000000005 Yards
    length1 * 2 = 2 Meters
    length1 / 2 = 0.5 Meters
    length1 > length2 = False
    length1 == length2 = False
    length1 * 2 == length2 = False
    length1 != length2 = True

  Mass--------------------------------------

    mass1 = 1 Grams
    mass2 = 2 Kilograms
    mass1 + mass2 = 2001 Grams
    mass2 - mass1 = 1999 Grams
    mass1 * 2 = 2 Grams
    mass1 / 2 = 0.5 Grams
    mass1 > mass2 = False
    mass1 == mass2 = False
    mass1 * 2 == mass2 = False
    mass1 != mass2 = True

  Time--------------------------------------

    time1 = 1 Seconds
    time2 = 2 Minutes
    time1 + time2 = 121 Seconds
    time2 - time1 = 119 Seconds
    time1 * 2 = 2 Seconds
    time1 / 2 = 0.5 Seconds
    time1 > time2 = False
    time1 == time2 = False
    time1 * 2 == time2 = False
    time1 != time2 = True

  Area--------------------------------------

    area1 = 1 Meters*Meters
    area2 = 2 Yards*Yards
    area1 + area2 = 5.7636 Yards*Yards
    area2 - area1 = -1.7635999999999998 Yards*Yards
    area1 * 2 = 2 Meters*Meters
    area1 / 2 = 0.5 Meters*Meters
    area1 > area2 = True
    area1 == area2 = False
    area1 * 2 == area2 = False
    area1 != area2 = True

  Volume--------------------------------------

    volume1 = 1 Meters*Meters*Meters
    volume2 = 2 Yards*Yards*Yards
    volume1 + volume2 = 9.301383999999999 Yards*Yards*Yards
    volume2 - volume1 = -5.301384 Yards*Yards*Yards
    volume1 * 2 = 2 Meters*Meters*Meters
    volume1 / 2 = 0.5 Meters*Meters*Meters
    volume1 > volume2 = True
    volume1 == volume2 = False
    volume1 * 2 == volume2 = False
    volume1 != volume2 = True
    volume1 / length1 = 1 Meters*Meters

  Speed--------------------------------------

    speed1 = 1 Meters/Seconds
    speed2 = 2 Inches/Milliseconds
    speed1 + speed2 = 2.03937 Inches/Milliseconds
    speed2 - speed1 = 1.96063 Inches/Milliseconds
    speed1 * 2 = 2 Meters/Seconds
    speed1 / 2 = 0.5 Meters/Seconds
    speed1 > speed2 = False
    speed1 == speed2 = False
    speed1 * 2 == speed2 = False
    speed1 != speed2 = True
    speed1 * time2 = 120 Meters
    speed3 = 6 NauticalMiles/Hours
    speed1 + speed3 = 4.086666666666666 Meters/Seconds

  Acceleration--------------------------------------

    acceleration1 = 5 Meters/(Seconds*Seconds)
    acceleration2 = 4 Inches/(Milliseconds*Milliseconds)
    acceleration1 + acceleration2 = 4.00019685 Inches/(Milliseconds*Milliseconds)
    acceleration2 - acceleration1 = 3.99980315 Inches/(Milliseconds*Milliseconds)
    acceleration1 * 2 = 10 Meters/(Seconds*Seconds)
    acceleration1 / 2 = 2.5 Meters/(Seconds*Seconds)
    acceleration1 > acceleration2 = False
    acceleration1 == acceleration2 = False
    acceleration1 * 2 == acceleration2 = False
    acceleration1 != acceleration2 = True
    acceleration1 * time2 = 600 Meters/Seconds

  Force--------------------------------------

    force1 = 1 Kilograms*Meters/Seconds/Seconds
    force2 = 2 Kilograms*Meters/Seconds/Seconds
    force1 + force2 = 3 Kilograms*Meters/Seconds/Seconds
    force2 - force1 = 1 Kilograms*Meters/Seconds/Seconds
    force1 * 2 = 2 Kilograms*Meters/Seconds/Seconds
    force1 / 2 = 0.5 Kilograms*Meters/Seconds/Seconds
    force1 > force2 = False
    force1 == force2 = False
    force1 * 2 == force2 = True
    force1 != force2 = True

  ElectricCurrent--------------------------------------

    electricCurrent1 = 5 Coulombs/Seconds
    electricCurrent2 = 4 Coulombs/Seconds
    electricCurrent1 + electricCurrent2 = 9 Coulombs/Seconds
    acceleration2 - electricCurrent1 = -1 Coulombs/Seconds
    electricCurrent1 * 2 = 10 Coulombs/Seconds
    electricCurrent1 / 2 = 2.5 Coulombs/Seconds
    electricCurrent1 > electricCurrent2 = True
    electricCurrent1 == electricCurrent2 = False
    electricCurrent1 * 2 == electricCurrent2 = False
    electricCurrent1 != electricCurrent2 = True

  AngularSpeed--------------------------------------

    angularSpeed1 = 10 Radians/Seconds
    angularSpeed2 = 2200 Degrees/Milliseconds
    angularSpeed1 + angularSpeed2 = 2200.5729577951306 Degrees/Milliseconds
    angularSpeed2 - angularSpeed1 = 2199.4270422048694 Degrees/Milliseconds
    angularSpeed1 * 2 = 20 Radians/Seconds
    angularSpeed1 / 2 = 5 Radians/Seconds
    angularSpeed1 > angularSpeed2 = False
    angularSpeed1 == angularSpeed2 = False
    angularSpeed1 * 2 == angularSpeed2 = False
    angularSpeed1 != angularSpeed2 = True
    angularSpeed1 * time2 = 1200 Radians

  AngularAcceleration--------------------------------------

    angularAcceleration1 = 5000 Radians/(Seconds*Seconds)
    angularAcceleration2 = 0.4 Degrees/(Milliseconds*Milliseconds)
    angularAcceleration1 + angularAcceleration2 = 0.6864788975654117 Degrees/(Milliseconds*Milliseconds)
    angularAcceleration2 - angularAcceleration1 = 0.1135211024345884 Degrees/(Milliseconds*Milliseconds)
    angularAcceleration1 * 2 = 10000 Radians/(Seconds*Seconds)
    angularAcceleration1 / 2 = 2500 Radians/(Seconds*Seconds)
    angularAcceleration1 > angularAcceleration2 = False
    angularAcceleration1 == angularAcceleration2 = False
    angularAcceleration1 * 2 == angularAcceleration2 = False
    angularAcceleration1 != angularAcceleration2 = True
    angularAcceleration1 * time2 = 600000 Radians/Seconds

  Density--------------------------------------

    density1 = 5 Kilograms/Meters/Meters/Meters
    density2 = 2000 Grams/Meters/Meters/Meters
    density1 + density2 = 7000 Grams/Meters/Meters/Meters
    density2 - density1 = -3000 Grams/Meters/Meters/Meters
    density1 * 2 = 10 Kilograms/Meters/Meters/Meters
    density1 / 2 = 2.5 Kilograms/Meters/Meters/Meters
    density1 > density2 = True
    density1 == density2 = False
    density1 * 2 == density2 = False
    density1 != density2 = True

Cached Result
Last Run:	8:14:59 pm
Compile:	0.237s
Execute:	0.25s
Memory:	24.97Mb
CPU:	0.487s

View IL Code