public UnitPathStack PathToSIBaseUnits()
        {
            if (this.IsStronglyTyped)
            {
                //get the corresponding unit in the SI System
                Type InnerUnitType = Unit.GetDefaultSIUnitTypeOf(this.QuantityType);

                if (InnerUnitType == null && this.QuantityType == typeof(PolarLength <>))
                {
                    InnerUnitType = Unit.GetDefaultSIUnitTypeOf(typeof(Length <>));
                }

                if (InnerUnitType == null)
                {
                    //some quantities don't have strongly typed si units

                    //like knot unit there are no corresponding velocity unit in SI
                    //  we need to replace the knot unit with mixed unit to be able to do the conversion

                    // first we should reach default unit
                    UnitPathStack path = this.PathToDefaultUnit();

                    //then test the system of the current unit if it was other than Metric.SI
                    //    then we must jump to SI otherwise we are already in default SI
                    if (this.UnitSystem == "Metric.SI" && this.UnitExponent == 1)
                    {
                        //because no unit in SI with exponent = 1 don't have direct unit type
                        throw new NotImplementedException("Impossible reach by logic");
                    }
                    else
                    {
                        // We should cross the system boundary
                        UnitPathItem DefaultPItem;
                        UnitPathItem RefUPI;

                        DefaultPItem = path.Peek();
                        if (DefaultPItem.Unit.ReferenceUnit != null)
                        {
                            RefUPI = new UnitPathItem
                            {
                                Numerator   = DefaultPItem.Unit.ReferenceUnitNumerator,
                                Denominator = DefaultPItem.Unit.ReferenceUnitDenominator,
                                //Shift = DefaultPItem.Unit.ReferenceUnitShift,
                                Unit = DefaultPItem.Unit.ReferenceUnit
                            };

                            path.Push(RefUPI);
                        }
                    }
                    return(path);
                }
                else
                {
                    Unit SIUnit = (Unit)Activator.CreateInstance(InnerUnitType);
                    SIUnit.UnitExponent  = this.UnitExponent;
                    SIUnit.UnitDimension = this.UnitDimension;

                    UnitPathStack up = this.PathToUnit(SIUnit);

                    if (!SIUnit.IsBaseUnit)
                    {
                        if (SIUnit.UnitDimension.IsDimensionless && SIUnit.IsStronglyTyped)
                        {
                            //for dimensionless units like radian, stradian
                            //do nothing.
                        }
                        else
                        {
                            //expand the unit
                            Unit          expandedUnit = ExpandMetricUnit((MetricUnit)SIUnit);
                            UnitPathStack expath       = expandedUnit.PathToSIBaseUnits();

                            while (expath.Count > 0)
                            {
                                up.Push(expath.Pop());
                            }
                        }
                    }

                    return(up);
                }
            }


            UnitPathStack Pathes = new UnitPathStack();

            foreach (Unit un in this.SubUnits)
            {
                UnitPathStack up = null;

                up = un.PathToSIBaseUnits();

                while (up.Count > 0)
                {
                    UnitPathItem upi = up.Pop();

                    if (un.IsInverted)
                    {
                        upi.Invert();
                    }

                    Pathes.Push(upi);
                }
            }
            return(Pathes);
        }
        /// <summary>
        /// Gets the path to the unit starting from current unit.
        /// </summary>
        /// <param name="unit"></param>
        /// <returns></returns>
        public UnitPathStack PathToUnit(Unit unit)
        {
            lock (CachedPaths)
            {
                #region Caching
                //because this method can be a lengthy method we try to check for cached pathes first.
                UnitPathStack cachedPath;
                if (EnableUnitsCaching)
                {
                    if (CachedPaths.TryGetValue(UnitToUnitSymbol(this, unit), out cachedPath))
                    {
                        return((UnitPathStack)cachedPath.Clone());   //<--- Clone

                        //Why CLONE :D ??  because the unit path is a stack and I use Pop all the time
                        // during the application, and there were hidden error that poping from unit path in the
                        // cached store will not get them back again ;)
                        //  I MUST return cloned copy of the UnitPath.
                    }
                }
                #endregion

                #region validity of conversion
                if (this.UnitDimension.IsDimensionless == true && unit.UnitDimension.IsDimensionless == true)
                {
                }
                else
                {
                    //why I've tested dimensioless in begining??
                    //   because I want special dimensionless quantities like angle and solid angle to be treated
                    //   as normal dimensionless values

                    if (this.UnitDimension.Equals(unit.UnitDimension) == false)
                    {
                        throw new UnitsNotDimensionallyEqualException();
                    }
                }
                #endregion

                //test if one of the units are not strongly typed
                //  because this needs special treatment. ;)
                if (this.IsStronglyTyped == false || unit.IsStronglyTyped == false)
                {
                    #region Complex units

                    //the unit is not strongly typed so we need to make conversion to get its conversion
                    // Source unit ==> SI Base Units
                    // target unit ==> SI BaseUnits

                    UnitPathStack SourcePath = this.PathToSIBaseUnits();
                    UnitPathStack TargetPath = unit.PathToSIBaseUnits();

                    UnitPathStack Tito = new UnitPathStack();

                    while (SourcePath.Count > 0)
                    {
                        Tito.Push(SourcePath.Pop());
                    }
                    //we have to invert the target
                    while (TargetPath.Count > 0)
                    {
                        UnitPathItem upi = TargetPath.Pop();
                        upi.Invert();

                        Tito.Push(upi);
                    }

                    //first location in cache look below for the second location.

                    if (EnableUnitsCaching)
                    {
                        CachedPaths.Add(UnitToUnitSymbol(this, unit), (UnitPathStack)Tito.Clone());
                    }

                    return(Tito);

                    #endregion
                }

                // 1- Get Path default unit to current unit.

                UnitPathStack FromMeToDefaultUnit = this.PathToDefaultUnit();

                // 2- Get Path From Default unit to the passed unit.

                UnitPathStack FromDefaultUnitToTargetUnit = unit.PathFromDefaultUnit();

                // 3- check if the two units are in the same unit system
                //  if the units share the same parent don't jump

                UnitPathStack SystemsPath = null;

                bool NoBoundaryCross = false;

                if (this.UnitSystem == unit.UnitSystem)
                {
                    NoBoundaryCross = true;
                }
                else
                {
                    //test for that units parents are the same

                    string ThisParent = this.UnitSystem.IndexOf('.') > -1 ?
                                        this.UnitSystem.Substring(0, this.UnitSystem.IndexOf('.')) :
                                        this.UnitSystem;

                    string TargetParent = unit.UnitSystem.IndexOf('.') > -1 ?
                                          unit.UnitSystem.Substring(0, unit.UnitSystem.IndexOf('.')) :
                                          unit.UnitSystem;


                    if (ThisParent == TargetParent)
                    {
                        NoBoundaryCross = true;
                    }
                }



                if (NoBoundaryCross)
                {
                    //no boundary cross should occur

                    //if the two units starts with Metric then no need to cross boundaries because
                    //they have common references in metric.
                }
                else
                {
                    //then we must go out side the current unit system
                    //all default units are pointing to the SIUnit system this is a must and not option.

                    //get the default unit of target


                    // to cross the boundary
                    // we should know the non SI system that we will cross it
                    // we have two options

                    // 1- FromMeToDefaultUnit if (Me unit is another system (not SI)
                    //     in this case we will take the top unit to get its reference
                    // 2- FromDefaultUnitToTargetUnit (where default unit is not SI)
                    //     and in this case we will take the last bottom unit of stack and get its reference


                    SystemsPath = new UnitPathStack();

                    UnitPathItem DefaultPItem;
                    UnitPathItem RefUPI;

                    Unit SourceDefaultUnit = FromMeToDefaultUnit.Peek().Unit;

                    if (SourceDefaultUnit.UnitSystem != "Metric.SI" && SourceDefaultUnit.GetType() != typeof(Shared.Second))
                    {
                        //from source default unit to the si
                        DefaultPItem = FromMeToDefaultUnit.Peek();
                        RefUPI       = new UnitPathItem
                        {
                            Numerator   = DefaultPItem.Unit.ReferenceUnitNumerator,
                            Denominator = DefaultPItem.Unit.ReferenceUnitDenominator,
                            //Shift = DefaultPItem.Unit.ReferenceUnitShift,
                            Unit = DefaultPItem.Unit.ReferenceUnit
                        };
                    }
                    else
                    {
                        // from target default unit to si
                        DefaultPItem = FromDefaultUnitToTargetUnit.ElementAt(FromDefaultUnitToTargetUnit.Count - 1);
                        RefUPI       = new UnitPathItem
                        {
                            //note the difference here
                            //I made the opposite assignments because we are in reverse manner

                            Numerator   = DefaultPItem.Unit.ReferenceUnitDenominator, // <=== opposite
                            Denominator = DefaultPItem.Unit.ReferenceUnitNumerator,   // <===
                            //Shift = 0-DefaultPItem.Unit.ReferenceUnitShift,
                            Unit = DefaultPItem.Unit.ReferenceUnit
                        };
                    }


                    if (RefUPI.Unit != null)
                    {
                        SystemsPath.Push(RefUPI);
                    }
                    else
                    {
                        //both default units were SI units without references

                        //note:
                        // when define units in unit cloud for quantity
                        //  either make all units reference SI units without default unit
                        // or make one default unit and make the rest of units reference it.
                    }
                }


                //combine the two paths
                UnitPathStack Total = new UnitPathStack();

                //we are building the conversion stairs
                // will end like a stack


                //begin from me unit to default unit
                for (int i = FromMeToDefaultUnit.Count - 1; i >= 0; i--)
                {
                    Total.Push(FromMeToDefaultUnit.ElementAt(i));
                }

                Unit One = new Unit(typeof(DimensionlessQuantity <>));

                //cross the system if we need to .
                if (SystemsPath != null)
                {
                    Total.Push(new UnitPathItem {
                        Denominator = 1, Numerator = 1, Unit = One
                    });
                    for (int i = SystemsPath.Count - 1; i >= 0; i--)
                    {
                        Total.Push(SystemsPath.ElementAt(i));
                    }
                    Total.Push(new UnitPathItem {
                        Denominator = 1, Numerator = 1, Unit = One
                    });
                }

                // from default unit to target unit
                for (int i = FromDefaultUnitToTargetUnit.Count - 1; i >= 0; i--)
                {
                    Total.Push(FromDefaultUnitToTargetUnit.ElementAt(i));
                }

                //another check if the units are inverted then
                // go through all items in path and invert it also

                if (this.IsInverted && unit.IsInverted)
                {
                    foreach (UnitPathItem upi in Total)
                    {
                        upi.Invert();
                    }
                }

                //Second location in cache  look above for the first one in the same function here :D
                if (EnableUnitsCaching)
                {
                    CachedPaths.Add(UnitToUnitSymbol(this, unit), (UnitPathStack)Total.Clone());
                }

                return(Total);
            }
        }