/// <summary>
/// Obtém o valor inteiro mais próximo de uma fracção.
/// </summary>
/// <param name="source">A facção.</param>
/// <returns>O valor inteiro.</returns>
/// <exception cref="ArgumentNullException">Caso o argumento seja nulo.</exception>
public Fraction <int> GetNearest(Fraction <int> source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
else
{
var integerPart = source.IntegralPart(this.fractionDomain);
if (integerPart == 0)
{
return(new Fraction <int>(0, 1, this.fractionDomain));
}
else
{
var fractionPart = source.FractionalPart(this.fractionDomain);
var factor = fractionPart.Denominator / fractionPart.Numerator;
if (factor > 2)
{
++integerPart;
}
else if (factor < -2)
{
--integerPart;
}
return(new Fraction <int>(integerPart, 1, this.fractionDomain));
}
}
}
/// <summary>
/// Indica se é possível converter o uma fracção para o tipo externo.
/// </summary>
/// <param name="objectToConvert">A fracção em análise.</param>
/// <returns>Verdadeiro caso a conversão seja possível e falso caso contrário.</returns>
public bool CanApplyDirectConversion(Fraction <FractionElementType> objectToConvert)
{
if (objectToConvert == null)
{
return(false);
}
else
{
var fractionPartValue = objectToConvert.FractionalPart(this.domain).Numerator;
if (this.domain.IsAdditiveUnity(fractionPartValue))
{
return(this.outTypeToFractionTypeConversion.CanApplyDirectConversion(
objectToConvert.IntegralPart(this.domain)));
}
else
{
return(false);
}
}
}
/// <summary>
/// Obtém o valor inteiro mais próximo de uma fracção.
/// </summary>
/// <param name="source">A facção.</param>
/// <returns>O valor inteiro.</returns>
/// <exception cref="ArgumentNullException">Caso o argumento seja nulo.</exception>
public BigInteger GetNearest(Fraction <BigInteger> source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
else
{
var integerPart = source.IntegralPart(this.domain);
var fractionPart = source.FractionalPart(this.domain);
var factor = fractionPart.Denominator / fractionPart.Numerator;
if (factor > 2)
{
++integerPart;
}
else if (factor < -2)
{
--integerPart;
}
return(integerPart);
}
}
/// <summary>
/// Indica se é possível converter uma fracção de coeficientes num coeficiente.
/// </summary>
/// <remarks>
/// Uma fracção de coeficientes é convertível num coeficiente caso o seu denominador seja uma unidade
/// aditiva ou o seu inverso aditivo.
/// </remarks>
/// <param name="objectToConvert">O coeficiente em análise.</param>
/// <returns>Verdadeiro caso a conversão seja possível e falso caso contrário.</returns>
public bool CanApplyDirectConversion(Fraction <ElementType> objectToConvert)
{
if (objectToConvert == null)
{
return(false);
}
else
{
var fractionPartValue = objectToConvert.FractionalPart(this.domain).Numerator;
if (this.domain.IsAdditiveUnity(fractionPartValue))
{
return(true);
}
else if (this.domain.IsAdditiveUnity(this.domain.AdditiveInverse(fractionPartValue)))
{
return(true);
}
else
{
return(false);
}
}
}