¿Cómo expresar valores numéricos usando fracciones en el cálculo de asp.net?
Fracción pública
{
divisor ulong;
bonificación ulong;
///& lt ; Resumen>
///Denominador
///</summary >
Divisor ulong público
{
Obtener
{
Devolver el divisor;
}
Establecer
{
Si (¡valor! = 0)
Divisor = valor;
Otro
Lanzadonuevaexcepción("El denominador no puede ser 0." );
}
}
///<Resumen>
//Nolecule
///< /summary>
Dividendo público ulong
{
Obtener
{
Dividendo de retorno;
}
Configuración
{
Dividendo = valor;
}
}
Valor doble público
{
Obtener
{
Retorno (doble) dividendo/(doble) divisor;
}
}
Cadena de anulación pública ToString()
{
Bonos de devolución. ToString() + "/" + divisor. ToString();
}
///& lt;Resumen>
///Constructor
/// </ resumen>
Puntuación pública(){ }
///<Resumen>
///Convertir la cadena Convertir a fracción
///</summary>
///<param name = "numberString">Fraction string
///<devuelve & instancia de gtFraction, si la conversión falla , devuelve nulo
Fracción pública estática ConvertToFraction(cadena cadena numérica)
{
if(String.IsNullOrEmpty(NumberString))
Devuelve nulo
cadena[] resultado = cadenanúmero. Split('/');
Si (resultado. longitud! = 2)
Devuelve nulo
divisor ulong, dividendo;
intenta
{
divisor=convertir. ToUInt64(resultado[1]);
Dividendo = Convertir.
touint 64(resultado[0]);
}
Capturar
{
Devolver nulo
}
if(divisor == 0)
Devuelve nulo
Fracción = nueva Fracción();
fracción.dividendo = dividendo ;
fracción.divisor =divisor;
Fracción de retorno;
}
///& lt;Resumen>
p >///Suma
///& lt;/summary & gt;
///& lt;nombre del parámetro = "fracción" & gt& lt/ param & gt;
///& lt;returns & gt& lt/returns & gt;
Suma de fracción pública (fracción fracción)
{
Resultado de la puntuación = nueva puntuación();
Resultado. Divisor = minCommonMultiple(this.Divisor, Fraction.Divisor);
Resultado. Bonificación = esto. Resultado dividendo*. divisor/esto. Divisor + fracción. Resultado dividendo*. Divisor/fracción. Divisor;
ReturnSimplify(resultado);
}
///<Resumen>
///Resta
///& lt;/summary & gt;
///& lt;nombre del parámetro = "fracción" & gt& lt/param & gt;
// /<returns></returns>
Resta de fracción pública (fracción fracción)
{
Resultado de fracción = nueva puntuación();
Resultado. Divisor = minCommonMultiple(this.Divisor, Fraction.Divisor);
Resultado. Bonificación = esto. Resultado dividendo*. divisor/esto. fracción divisoria. Dividendo*
Resultados. Divisor/fracción. Divisor;
Devolver Simplificar(resultado);
}
///<Resumen>
///Multiplicación
///</summary>
///<param name = "fracción"></param>
///<returns></returns>
Multiplicación de fracciones públicas (decimal fraccionario)
{
Resultado de la fracción = new Score();
Resultado. divisor = esto. divisor*fracción. Divisor;
Resultado. Bonificación = esto. Dividendo*Fracción. Dividendo;
ReturnSimplify(resultado);
}
///<Resumen>
///División
///& lt;/summary & gt;
///& lt;nombre del parámetro = "fracción" & gt& lt/param & gt;
// /<returns></returns>
División de fracción pública (fracción decimal)
{
Resultado de la fracción = nueva puntuación();
Resultado. divisor = esto. divisor*fracción. Dividendo;
Resultados. Bonificación = esto. Dividendo*Fracción.
Divisor;
Regresar Simplificar(resultado);
}
///<Resumen>
///Múltiplos comunes mínimos.
///& lt;/summary & gt;
///& lt; parámetro nombre="num1 " >& lt/param & gt;
///& lt;param name="num2 ">& lt/param & gt;
///& lt;returns & gt& lt/returns & gt;
Estático privado ulong minCommonMultiple(ulong num 1, ulong num2)
{
ulong MCD = maxCommonDivisor(num 1, num 2);
if ( mcd == 1)
Devuelve num 1 * num 2;
Devuelve num 1 * num 2/MCD;
}
/ //<Summary>
///Máximo común divisor
///</summary >
/// & lt;param name= "num1 " >& lt/param & gt;
///& lt;param nombre="num2 " >& lt/param & gt;
///& lt ;returns & gt& lt/returns & gt;
Divisor común máximo común estático de ulong(ulong num 1, ulong num2)
{
ulong min, max
if(núm 1 & lt; núm2)
{
mín = núm 1;
máx = núm2
}
Otro
{
min = num2
max = num 1;
}
doble tmp =((doble)max/(doble)min);
ulong tmp 2 =(ulong)tmp;
if (tmp == ( double)tmp2)
{
Devolver tmp2
}
Devolver 1;
}
///<Resumen>
///Simplificar
///</summary>
p>///& lt ; param name = " fracción " & gt& lt/param & gt;
///& lt; devuelve & gt& lt/returns & gt; fracción)
{
ulong div = maxCommonDivisor(fracción. divisor, fracción. Dividendo);
Fracción. Divisor/= div;
Fracción. dividendo/= div;
Fracción de retorno;
}
}
Ejemplo:
texto de cadena 1 = " 1/3 ";
texto de cadena 2 = " 1/4 ";
Fracción a = fracción. converttofaction(texto 1);
Fracción b = fracción.
converttofaction(texto 2);
If (a!= null & amp& ampb!=null)
{
Fracción c = a . ;
Consola. WriteLine(c . valor);
Consola. WriteLine(c . ToString());
}
Otro
{
Consola. WriteLine("La conversión no es válida.");
}
En su uso real, reemplace text1 y text2 con sus valores de texto y asigne ToString() de C para mostrar solo el texto del resultado.