public void EqualsIsImplemented()
{
CoefficientOfThermalExpansion v = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.True(v.Equals(CoefficientOfThermalExpansion.FromInverseKelvin(1), CoefficientOfThermalExpansion.FromInverseKelvin(InverseKelvinTolerance)));
Assert.False(v.Equals(CoefficientOfThermalExpansion.Zero, CoefficientOfThermalExpansion.FromInverseKelvin(InverseKelvinTolerance)));
}
public void CompareToIsImplemented()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.Equal(0, inversekelvin.CompareTo(inversekelvin));
Assert.True(inversekelvin.CompareTo(CoefficientOfThermalExpansion.Zero) > 0);
Assert.True(CoefficientOfThermalExpansion.Zero.CompareTo(inversekelvin) < 0);
}
public void ConversionRoundTrip()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromInverseDegreeCelsius(inversekelvin.InverseDegreeCelsius).InverseKelvin, InverseDegreeCelsiusTolerance);
AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(inversekelvin.InverseDegreeFahrenheit).InverseKelvin, InverseDegreeFahrenheitTolerance);
AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromInverseKelvin(inversekelvin.InverseKelvin).InverseKelvin, InverseKelvinTolerance);
}
public void InverseKelvinToCoefficientOfThermalExpansionUnits()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, inversekelvin.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, inversekelvin.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, inversekelvin.InverseKelvin, InverseKelvinTolerance);
}
public void As()
{
var inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius), InverseDegreeCelsiusTolerance);
AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit), InverseDegreeFahrenheitTolerance);
AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, inversekelvin.As(CoefficientOfThermalExpansionUnit.InverseKelvin), InverseKelvinTolerance);
}
public void TryParseUnit()
{
{
Assert.True(CoefficientOfThermalExpansion.TryParseUnit("°C⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsedUnit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParseUnit("1/°C", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsedUnit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParseUnit("°F⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsedUnit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParseUnit("1/°F", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsedUnit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParseUnit("K⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsedUnit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParseUnit("1/K", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsedUnit);
}
}
public void EqualsRelativeToleranceIsImplemented()
{
var v = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.True(v.Equals(CoefficientOfThermalExpansion.FromInverseKelvin(1), InverseKelvinTolerance, ComparisonType.Relative));
Assert.False(v.Equals(CoefficientOfThermalExpansion.Zero, InverseKelvinTolerance, ComparisonType.Relative));
}
public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
{
var quantity = new CoefficientOfThermalExpansion();
Assert.Equal(0, quantity.Value);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, quantity.Unit);
}
public void Equals_SameType_IsImplemented()
{
var a = CoefficientOfThermalExpansion.FromInverseKelvin(1);
var b = CoefficientOfThermalExpansion.FromInverseKelvin(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
}
public void ConvertFrom_GivenStringWithPower_minus1()
{
var converter = new QuantityTypeConverter <CoefficientOfThermalExpansion>();
ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K⁻¹"));
Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K^-1"));
}
public void Ctor_WithInfinityValue_CreateQuantityAndAffectInfinityValue()
{
var positiveInfinityQuantity = new CoefficientOfThermalExpansion(double.PositiveInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin);
var negativeInfinityQuantity = new CoefficientOfThermalExpansion(double.NegativeInfinity, CoefficientOfThermalExpansionUnit.InverseKelvin);
Assert.True(double.IsPositiveInfinity(positiveInfinityQuantity.Value));
Assert.True(double.IsNegativeInfinity(negativeInfinityQuantity.Value));
}
public void Equals_QuantityAsObject_IsImplemented()
{
object a = CoefficientOfThermalExpansion.FromInverseKelvin(1);
object b = CoefficientOfThermalExpansion.FromInverseKelvin(2);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
Assert.False(a.Equals((object)null));
}
public void ToUnit(CoefficientOfThermalExpansionUnit unit)
{
var inBaseUnits = CoefficientOfThermalExpansion.From(1.0, CoefficientOfThermalExpansion.BaseUnit);
var converted = inBaseUnits.ToUnit(unit);
var conversionFactor = GetConversionFactor(unit);
AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, (double)converted.Value, conversionFactor.Tolerence);
Assert.Equal(unit, converted.Unit);
}
public void ArithmeticOperators()
{
CoefficientOfThermalExpansion v = CoefficientOfThermalExpansion.FromInverseKelvin(1);
AssertEx.EqualTolerance(-1, -v.InverseKelvin, InverseKelvinTolerance);
AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion.FromInverseKelvin(3)-v).InverseKelvin, InverseKelvinTolerance);
AssertEx.EqualTolerance(2, (v + v).InverseKelvin, InverseKelvinTolerance);
AssertEx.EqualTolerance(10, (v*10).InverseKelvin, InverseKelvinTolerance);
AssertEx.EqualTolerance(10, (10*v).InverseKelvin, InverseKelvinTolerance);
AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion.FromInverseKelvin(10)/5).InverseKelvin, InverseKelvinTolerance);
AssertEx.EqualTolerance(2, CoefficientOfThermalExpansion.FromInverseKelvin(10)/CoefficientOfThermalExpansion.FromInverseKelvin(5), InverseKelvinTolerance);
}
public void To_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.SI));
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.CGS));
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.BI));
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.EE));
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.USC));
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.FPS));
Assert.Throws <ArgumentException>(() => inversekelvin.ToUnit(UnitSystem.Astronomical));
}
public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(CoefficientOfThermalExpansionUnit unit)
{
// See if there is a unit available that is not the base unit.
var fromUnit = CoefficientOfThermalExpansion.Units.FirstOrDefault(u => u != CoefficientOfThermalExpansion.BaseUnit && u != CoefficientOfThermalExpansionUnit.Undefined);
// If there is only one unit for the quantity, we must use the base unit.
if (fromUnit == CoefficientOfThermalExpansionUnit.Undefined)
fromUnit = CoefficientOfThermalExpansion.BaseUnit;
var quantity = CoefficientOfThermalExpansion.From(3.0, fromUnit);
var converted = quantity.ToUnit(unit);
Assert.Equal(converted.Unit, unit);
}
public void EqualityOperators()
{
CoefficientOfThermalExpansion a = CoefficientOfThermalExpansion.FromInverseKelvin(1);
CoefficientOfThermalExpansion b = CoefficientOfThermalExpansion.FromInverseKelvin(2);
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a != a);
// ReSharper restore EqualExpressionComparison
}
public void ComparisonOperators()
{
CoefficientOfThermalExpansion oneInverseKelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
CoefficientOfThermalExpansion twoInverseKelvin = CoefficientOfThermalExpansion.FromInverseKelvin(2);
Assert.True(oneInverseKelvin < twoInverseKelvin);
Assert.True(oneInverseKelvin <= twoInverseKelvin);
Assert.True(twoInverseKelvin > oneInverseKelvin);
Assert.True(twoInverseKelvin >= oneInverseKelvin);
Assert.False(oneInverseKelvin > twoInverseKelvin);
Assert.False(oneInverseKelvin >= twoInverseKelvin);
Assert.False(twoInverseKelvin < oneInverseKelvin);
Assert.False(twoInverseKelvin <= oneInverseKelvin);
}
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = CoefficientOfThermalExpansion.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
AssertEx.EqualTolerance(1, quantity00.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, quantity00.Unit);
var quantity01 = CoefficientOfThermalExpansion.From(1, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
AssertEx.EqualTolerance(1, quantity01.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, quantity01.Unit);
var quantity02 = CoefficientOfThermalExpansion.From(1, CoefficientOfThermalExpansionUnit.InverseKelvin);
AssertEx.EqualTolerance(1, quantity02.InverseKelvin, InverseKelvinTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, quantity02.Unit);
}
public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
{
var quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
Func <object> AsWithSIUnitSystem = () => quantity.As(UnitSystem.SI);
if (SupportsSIUnitSystem)
{
var value = (double)AsWithSIUnitSystem();
Assert.Equal(1, value);
}
else
{
Assert.Throws <ArgumentException>(AsWithSIUnitSystem);
}
}
public void CoefficientOfThermalExpansion_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
{
var quantity = new CoefficientOfThermalExpansion(1, CoefficientOfThermalExpansionUnit.InverseKelvin);
QuantityInfo <CoefficientOfThermalExpansionUnit> quantityInfo = quantity.QuantityInfo;
Assert.Equal(CoefficientOfThermalExpansion.Zero, quantityInfo.Zero);
Assert.Equal("CoefficientOfThermalExpansion", quantityInfo.Name);
Assert.Equal(QuantityType.CoefficientOfThermalExpansion, quantityInfo.QuantityType);
var units = EnumUtils.GetEnumValues <CoefficientOfThermalExpansionUnit>().Except(new[] { CoefficientOfThermalExpansionUnit.Undefined }).ToArray();
var unitNames = units.Select(x => x.ToString());
// Obsolete members
Assert.Equal(units, quantityInfo.Units);
Assert.Equal(unitNames, quantityInfo.UnitNames);
}
public void Parse()
{
try
{
var parsed = CoefficientOfThermalExpansion.Parse("1 °C⁻¹", CultureInfo.GetCultureInfo("en-US"));
AssertEx.EqualTolerance(1, parsed.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsed.Unit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsed = CoefficientOfThermalExpansion.Parse("1 1/°C", CultureInfo.GetCultureInfo("en-US"));
AssertEx.EqualTolerance(1, parsed.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsed.Unit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsed = CoefficientOfThermalExpansion.Parse("1 °F⁻¹", CultureInfo.GetCultureInfo("en-US"));
AssertEx.EqualTolerance(1, parsed.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsed.Unit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsed = CoefficientOfThermalExpansion.Parse("1 1/°F", CultureInfo.GetCultureInfo("en-US"));
AssertEx.EqualTolerance(1, parsed.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsed.Unit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsed = CoefficientOfThermalExpansion.Parse("1 K⁻¹", CultureInfo.GetCultureInfo("en-US"));
AssertEx.EqualTolerance(1, parsed.InverseKelvin, InverseKelvinTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsed.Unit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsed = CoefficientOfThermalExpansion.Parse("1 1/K", CultureInfo.GetCultureInfo("en-US"));
AssertEx.EqualTolerance(1, parsed.InverseKelvin, InverseKelvinTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsed.Unit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
}
public void ToUnit()
{
var inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
var inversedegreecelsiusQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
AssertEx.EqualTolerance(InverseDegreeCelsiusInOneInverseKelvin, (double)inversedegreecelsiusQuantity.Value, InverseDegreeCelsiusTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, inversedegreecelsiusQuantity.Unit);
var inversedegreefahrenheitQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
AssertEx.EqualTolerance(InverseDegreeFahrenheitInOneInverseKelvin, (double)inversedegreefahrenheitQuantity.Value, InverseDegreeFahrenheitTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, inversedegreefahrenheitQuantity.Unit);
var inversekelvinQuantity = inversekelvin.ToUnit(CoefficientOfThermalExpansionUnit.InverseKelvin);
AssertEx.EqualTolerance(InverseKelvinInOneInverseKelvin, (double)inversekelvinQuantity.Value, InverseKelvinTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, inversekelvinQuantity.Unit);
}
public void EqualityOperators()
{
var a = CoefficientOfThermalExpansion.FromInverseKelvin(1);
var b = CoefficientOfThermalExpansion.FromInverseKelvin(2);
#pragma warning disable CS8073
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.False(a != a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a == null);
Assert.False(null == a);
// ReSharper restore EqualExpressionComparison
#pragma warning restore CS8073
}
public void ParseUnit()
{
try
{
var parsedUnit = CoefficientOfThermalExpansion.ParseUnit("°C⁻¹", CultureInfo.GetCultureInfo("en-US"));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsedUnit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsedUnit = CoefficientOfThermalExpansion.ParseUnit("1/°C", CultureInfo.GetCultureInfo("en-US"));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsedUnit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsedUnit = CoefficientOfThermalExpansion.ParseUnit("°F⁻¹", CultureInfo.GetCultureInfo("en-US"));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsedUnit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsedUnit = CoefficientOfThermalExpansion.ParseUnit("1/°F", CultureInfo.GetCultureInfo("en-US"));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsedUnit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsedUnit = CoefficientOfThermalExpansion.ParseUnit("K⁻¹", CultureInfo.GetCultureInfo("en-US"));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsedUnit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
try
{
var parsedUnit = CoefficientOfThermalExpansion.ParseUnit("1/K", CultureInfo.GetCultureInfo("en-US"));
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsedUnit);
} catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }
}
public void TryParse()
{
{
Assert.True(CoefficientOfThermalExpansion.TryParse("1 °C⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
AssertEx.EqualTolerance(1, parsed.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsed.Unit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParse("1 1/°C", CultureInfo.GetCultureInfo("en-US"), out var parsed));
AssertEx.EqualTolerance(1, parsed.InverseDegreeCelsius, InverseDegreeCelsiusTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeCelsius, parsed.Unit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParse("1 °F⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
AssertEx.EqualTolerance(1, parsed.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsed.Unit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParse("1 1/°F", CultureInfo.GetCultureInfo("en-US"), out var parsed));
AssertEx.EqualTolerance(1, parsed.InverseDegreeFahrenheit, InverseDegreeFahrenheitTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit, parsed.Unit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParse("1 K⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
AssertEx.EqualTolerance(1, parsed.InverseKelvin, InverseKelvinTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsed.Unit);
}
{
Assert.True(CoefficientOfThermalExpansion.TryParse("1 1/K", CultureInfo.GetCultureInfo("en-US"), out var parsed));
AssertEx.EqualTolerance(1, parsed.InverseKelvin, InverseKelvinTolerance);
Assert.Equal(CoefficientOfThermalExpansionUnit.InverseKelvin, parsed.Unit);
}
}
public void EqualsReturnsFalseOnNull()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.False(inversekelvin.Equals(null));
}
public void EqualsReturnsFalseOnTypeMismatch()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.False(inversekelvin.Equals(new object()));
}
public void CompareToThrowsOnNull()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.Throws <ArgumentNullException>(() => inversekelvin.CompareTo(null));
}
public void CompareToThrowsOnTypeMismatch()
{
CoefficientOfThermalExpansion inversekelvin = CoefficientOfThermalExpansion.FromInverseKelvin(1);
Assert.Throws <ArgumentException>(() => inversekelvin.CompareTo(new object()));
}
