para la segunda versión de la calculadora tenemos las mismas clases
naturales
enteros
racionales
reales
complejos
le agregamos mas operaciones como: %, xy , logxy, y√x, n!, %, 10x, sen(x), cos(x), tan(x),
senh(x), cosh(x), tanh(x).
PARA LOS NUMEROS NATURALES
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace calculadora
{
class CalculadoraNaturales
{
/// <summary>
/// Método que suma 2 números naturales, las variables son de tipo int por que no aceptan decimales
/// </summary>
/// <param name="x">primer número natural</param>
/// <param name="y">segundo número natural</param>
/// <returns>retorna un int con la suma de los 2 números naturales</returns>
public static int SumaNatural(int x, int y)
{
///verifica si los números ingresados están dentro del rango de los naturales
///si no es así retornará la excepción SystemException
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
int suma = x + y;
return suma;
}
}
/// <summary>
/// Método que resta 2 números naturales, las variables son de tipo int por que no aceptan decimales
/// </summary>
/// <param name="x">primer número natural</param>
/// <param name="y">segundo número natural</param>
/// <returns>retorna un int con la resta de los 2 números naturales</returns>
public static int RestaNatural(int x, int y)
{
///verifica si los números ingresados están dentro del rango de los naturales
///si no es así retornará la excepción SystemException
if (x < 0 || y < 0)
{
throw new SystemException();
}
///verifica si el segundo numero es mayor que el primero
///ya que esto produce que el resultado esté fuera de los numeros naturales
///de ser así retornará la excepción InvalidOperationException
else if (x < y)
{
throw new InvalidOperationException();
}
else
{
int resta = x - y;
return resta;
}
}
/// <summary>
/// Método que multiplica 2 números naturales, las variables son de tipo int por que no aceptan decimales
/// </summary>
/// <param name="x">primer número natural</param>
/// <param name="y">segundo número natural</param>
/// <returns>retorna un int con la multiplicación de los 2 números naturales</returns>
public static int MultiplicacionNatural(int x, int y)
{
///verifica si los números ingresados están dentro del rango de los naturales
///si no es así retornará la excepción SystemException
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
int multi = x * y;
return multi;
}
}
/// <summary>
/// Método que divide 2 números naturales, las variables son de tipo double por que aunque
/// no aceptan decimales, se operarán y el resultado se separará en su parte entera y decimal
/// </summary>
/// <param name="x">primer número natural</param>
/// <param name="y">segundo número natural</param>
/// <returns>retorna un string que es la división de los 2 números enteros separada en su parte entera y decimal</returns>
public static string DivisionNatural(double x, double y)
{
///verifica si los números ingresados están dentro del rango de los naturales
///si no es así retornará la excepción SystemException
if (x < 0 || y < 0)
{
throw new SystemException();
}
else if (y == 0)//verifica si el segundo número ingresado es 0 ya que la división por 0 no existe
{
throw new DivideByZeroException();
}
else
{
double division = x / y;
string res=division.ToString();
///transforma el resultado a string y verifica que no tenga coma, es decir que no sea racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
/// <summary>
/// devuelve el porcentaje de un número
/// </summary>
/// <param name="x">porcentaje</param>
/// <param name="y">numero para calcular porcentaje</param>
/// <returns>devuelve un string con el valor del porcentaje</returns>
public static string PorcentajeNatural(double x, double y)
{
///verifica si los números ingresados están dentro del rango de los naturales
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
double porcentaje = (x / 100)*y;
string res = porcentaje.ToString();
/// verifica que la solucion no sea racional transormando la solucion a string y verificando que no tenga coma
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
/// <summary>
/// Metodo que devuelve la potencia de un número elevado a otro
/// </summary>
/// <param name="x">Base</param>
/// <param name="y">Exponente</param>
/// <returns>devuelve un double con la potencia</returns>
public static double PotenciaNatural(double x, double y)
{
///verifica que los numeros ingresados no sean negativos
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
double pot = Math.Pow(x, y);
return pot;
}
}
/// <summary>
/// devuelve la raiz Y de un numero X
/// </summary>
/// <param name="x">numero para sacar raiz</param>
/// <param name="y">grado de la raiz</param>
/// <returns>devuelve un string con el valor del resultado</returns>
public static string RadicacionNatural(double x, double y)
{
///verifica que los numeros ingresados no sean negativos
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
///efectua la radicacion, como no hay una funcion que haga la operacion expresamos la raiz como X^(1/Y)
double radicacion = Math.Pow(x, (1 / y));
string res = radicacion.ToString();
///convierte el resultado a un string y verifica si es racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
/// <summary>
/// devuelve el factorial de un numero
/// </summary>
/// <param name="x">numero para calcular el factorial</param>
/// <returns>devuelve un entero con el factorial</returns>
public static int Factorial(int x)
{
///verifica que el numero ingresado no sea negativo
if (x < 0)
{
throw new SystemException();
}
else
{
int i, fact = 1;
///el factorial de 0 es igual a 1
if (x == 0)
{
return fact;
}
else
{
for (i = 1; i <= x; i++)
{
fact = fact * i;
}
return fact;
}
}
}
/// <summary>
/// devuelve el numero que resulta de elevar 10 a una potencia
/// </summary>
/// <param name="x">potencia</param>
/// <returns>devuelve un double con el resultado de elevar 10 a una potencia</returns>
public static double PotenciaDiezNatural(int x)
{
///verifica que el número no sea negativo
if (x < 0)
{
throw new SystemException();
}
else
{
double pot10 = Math.Pow(10, x);
return pot10;
}
}
/// <summary>
/// Método que resuelve una ecuacion cuadrática de la forma ax^2+bx+c=0 mediante la fórmula de la ecuacion cuadrática
/// </summary>
/// <param name="x">valor cuadratico</param>
/// <param name="y">valor lineal</param>
/// <param name="z">valor entero</param>
/// <returns>devuelve un string con el resultado</returns>
public static string EcuacionCuadraticaNatural(double x, double y, double z)
{
///verifica que los numeros ingresados no sean negativos y que el valor cuadratico no sea 0
if (x <= 0 || y < 0 || z < 0)
{
throw new SystemException();
}
else
{
///verifica el valor del discriminante que es igual a b^2-4ac.
///si es mayor que 0 devolvera 2 resultados si es 0 devolvera 1 y si es menor devolvera una excepcion
double disc = Math.Pow(y, 2) - 4 * x * z;
if (disc > 0)
{
double raiz1 = (-y + (Math.Sqrt(disc))) / (2 * x);
double raiz2 = (-y - (Math.Sqrt(disc))) / (2 * x);
///verifica que las soluciones no sean negativas
if (raiz1 < 0 || raiz2 < 0)
{
throw new InvalidOperationException();
}
else
{
string res = "\nResultado 1: " + raiz1 + "\nResultado 2: " + raiz2;
///convierte las soluciones a string y verifica si tienen coma para saber si el resultado es racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
else if (disc < 0)
{
throw new InvalidOperationException();
}
else
{
double raiz = (-y + (Math.Sqrt(disc))) / (2 * x);
///verifica que la solucion no sea negativa
if (raiz < 0)
{
throw new InvalidOperationException();
}
else
{
string res = "\nResultado: " + raiz;
///convierte la solucion a string y verifica si tienen coma para saber si el resultado es racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
}
}
}
}
PARA LOS NUMEROS ENTEROS
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace calculadora
{
/// <summary>
/// Clase que contiene métodos para operar números enteros
/// </summary>
class CalculadoraEnteros
{
/// <summary>
/// Método que suma 2 números enteros ámbos de tipo int ya que este tipo de dato no admite decimales
/// </summary>
/// <param name="x">entero 1</param>
/// <param name="y">entero 2</param>
/// <returns>retorna un int que es la suma de los 2 numeros enteros</returns>
public static int SumaEntero(int x, int y)
{
int suma = x + y;
return suma;
}
/// <summary>
/// Método que resta 2 números enteros ámbos de tipo int ya que este tipo de dato no admite decimales
/// </summary>
/// <param name="x">entero 1</param>
/// <param name="y">entero 2</param>
/// <returns>retorna un int que es la resta de los 2 números enteros</returns>
public static int RestaEntero(int x, int y)
{
int resta = x - y;
return resta;
}
/// <summary>
/// Método que multiplica 2 números enteros ámbos de tipo int ya que este tipo de dato no admite decimales
/// </summary>
/// <param name="x">entero 1</param>
/// <param name="y">entero 2</param>
/// <returns>retorna un int que es la multiplicaión de los 2 números enteros</returns>
public static int MultiplicacionEntero(int x, int y)
{
int multi = x * y;
return multi;
}
/// <summary>
/// Método que divide 2 números enteros ámbos de tipo int ya que aunque este tipo de dato
/// no acepta decimales, se operarán las variables y el resultado se separará en su parte entera y decimal
/// </summary>
/// <param name="x">entero 1</param>
/// <param name="y">entero 2</param>
/// <returns>retorna un string que es la división de los 2 números enteros separada en su parte entera y decimal</returns>
public static string DivisionEntero(double x, double y)
{
//verifica si el segundo número ingresado es 0 ya que la división por 0 no existe
///si es así retornará la excepción DivideByZeroException
if (y == 0)
{
throw new DivideByZeroException();
}
else
{
double division = x / y;
string res=division.ToString();
///transforma el resultado a string y verifica que no tenga coma, es decir que no sea racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
/// <summary>
/// Metodo que calcula el porcentaje de un numero
/// </summary>
/// <param name="x">porcentaje</param>
/// <param name="y">numero a calcular</param>
/// <returns>devuelve un string con el resultado</returns>
public static string PorcentajeEntero(double x, double y)
{
double porcentaje = (x/100)*y;
string res = porcentaje.ToString();
///transforma el resultado a string y verifica que no tenga coma, es decir que no sea racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
/// <summary>
/// Método que calcula un numero elevado a una potencia
/// </summary>
/// <param name="x">numero a calcular</param>
/// <param name="y">potencia</param>
/// <returns>devuelve un string con el resultado</returns>
public static string PotenciaEntero(double x, double y)
{
double potencia = Math.Pow(x, y);
string res = potencia.ToString();
///transforma el resultado a string y verifica que no tenga coma, es decir que no sea racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
/// <summary>
/// Metodo que devuelve la raiz y de un numero x
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static string RadicacionEntero(double x, double y)
{
///verifica que el numero ingresado no sea negativo
if (x < 0)
{
throw new SystemException();
}
else
{
double radicacion = Math.Pow(x, (1 / y));
string res = radicacion.ToString();
///transforma el resultado a string y verifica que no tenga coma, es decir que no sea racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
/// <summary>
/// metodo que eleva 10 a una potencia
/// </summary>
/// <param name="x">potencia</param>
/// <returns>un numero resultado de elevar 10 a una potencia</returns>
public static double PotenciaDiezEntero(int x)
{
double pot10 = Math.Pow(10, x);
return pot10;
}
/// <summary>
/// metodo que devuelve la solucion de una ecuacion cuadrática de la forma ax^2+bx+c=0
/// </summary>
/// <param name="x">valor cuadrático</param>
/// <param name="y">valor lineal</param>
/// <param name="z">valor numerico</param>
/// <returns></returns>
public static string EcuacionCuadraticaEntero (double x, double y, double z)
{
///verifica que el valor cuadratico no sea 0
if (x == 0)
{
throw new SystemException();
}
else
{
double disc = Math.Pow(y, 2) - 4 * x * z;
///verifica el valor del discriminante que es igual a b^2-4ac.
///si es mayor que 0 devolvera 2 resultados si es 0 devolvera 1 y si es menor devolvera una excepcion
if (disc > 0)
{
double raiz1 = (-y + (Math.Sqrt(disc))) / (2 * x);
double raiz2 = (-y - (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado 1: " + raiz1 + "\nResultado 2: " + raiz2;
///convierte las soluciones a string y verifica si tienen coma para saber si el resultado es racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
else if (disc < 0)
{
throw new InvalidOperationException();
}
else
{
double raiz = (-y + (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado =" + raiz;
///convierte la solucion a string y verifica si tiene coma para saber si el resultado es racional
if (res.Contains(","))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
}
/// <summary>
/// metodo que calcula la solucion de una ecuacion lineal de forma ax+b=0
/// </summary>
/// <param name="x">valor lineal</param>
/// <param name="y">valor numérico</param>
/// <returns></returns>
public static double EcuacionLinealEntero(double x, double y)
{
///verifica que el valor lineal no sea 0
if (x == 0)
{
throw new SystemException();
}
else
{
double res = -(y / x);
string resultado = res.ToString();
///convierte las solucion a string y verifica si tiene coma para saber si el resultado es racional
if (resultado.Contains(""))
{
throw new InvalidOperationException();
}
else
{
return res;
}
}
}
}
}
PARA LOS NUMEROS RACIONALES
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace calculadora
{
/// <summary>
/// Clase que contiene métodos para operar números racionales
/// </summary>
class CalculadoraRacionales
{
/// <summary>
/// Método que suma 2 números racionales, son de tipo double por que este incluye decimales
/// </summary>
/// <param name="x">primer numero racional,</param>
/// <param name="y">segundo numero racional</param>
/// <returns>retorna un double con la suma de los 2 numeros racionales</returns>
public static double SumaRacional(double x, double y)
{
double suma = x + y;
return suma;
}
/// <summary>
/// Método que resta 2 números racionales, son de tipo double por que este incluye decimales
/// </summary>
/// <param name="x">primer numero racional,</param>
/// <param name="y">segundo numero racional</param>
/// <returns>retorna un double con la resta de los 2 numeros racionales</returns>
public static double RestaRacional(double x, double y)
{
double resta = x - y;
return resta;
}
/// <summary>
/// Método que multiplica 2 números racionales, son de tipo double por que este incluye decimales
/// </summary>
/// <param name="x">primer numero racional,</param>
/// <param name="y">segundo numero racional</param>
/// <returns>retorna un double con la multiplicación de los 2 numeros racionales</returns>
public static double MultiplicacionRacional(double x, double y)
{
double multi = x * y;
return multi;
}
/// <summary>
/// Método que divide 2 números racionales, son de tipo double por que este incluye decimales
/// </summary>
/// <param name="x">primer numero racional,</param>
/// <param name="y">segundo numero racional</param>
/// <returns>retorna un double con la división de los 2 numeros racionales</returns>
public static double DivisionRacional(double x, double y)
{
///verifica si el segundo número ingresado es 0 ya que la división por 0 no existe
///si es así retornará la excepción DivideByZeroException
if (y == 0)
{
throw new DivideByZeroException();
}
else
{
double div = x / y;
return div;
}
}
/// <summary>
/// metodo que calcula el porcentaje de un número
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">porcentaje</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double PorcentajeRacional(double x, double y)
{
double por = (x / 100) * y;
return por;
}
/// <summary>
/// metodo que calcula el resultado de elevar un numero a una potencia
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">potencia</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double PotenciaRacional(double x, double y)
{
double pot = Math.Pow(x, y);
return pot;
}
/// <summary>
/// metodo que calcula el logaritmo de un numero en una base determinada
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">base</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double LogaritmoRacional(double x, double y)
{
///verifica que el numero a calcular y la base no sean negativos
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
double log = Math.Log(x, y);
return log;
}
}
/// <summary>
/// metodo que calcula la raiz de un numero
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">raiz</param>
/// <returns>devuelve un valor con el resultado</returns>
public static double RadicacionRacional(double x, double y)
{
///verifica que el numero a calcular no sea negativo
if (x < 0)
{
throw new SystemException();
}
else
{
double rad = Math.Pow(x, (1 / y));
return rad;
}
}
/// <summary>
/// metodo que calcula el resultado de elevar 10 a una potencia
/// </summary>
/// <param name="x">potencia</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double PotenciaDiezRacional(double x)
{
double pot10 = Math.Pow(10, x);
return pot10;
}
/// <summary>
/// metodo que calcula el seno de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double SenoRacional(double x)
{
double sen = Math.Sin(x);
return sen;
}
/// <summary>
/// metodo que calcula el seno hiperbolico de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double SenoHRacional(double x)
{
double senh = Math.Sinh(x);
return senh;
}
/// <summary>
/// metodo que calcula el coseno de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double CosenoRacional(double x)
{
double cos = Math.Cos(x);
return cos;
}
/// <summary>
/// metodo que calcula el coseno hiperbolico de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double CosenoHRacional(double x)
{
double cosh = Math.Cosh(x);
return cosh;
}
/// <summary>
/// metodo que calcula la tangente de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double TangenteRacional(double x)
{
double tan = Math.Tan(x);
return tan;
}
/// <summary>
/// metodo que calcula la tangente hiperbolica de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double TangenteHRacional(double x)
{
double tanh = Math.Tanh(x);
return tanh;
}
/// <summary>
/// metodo que devuelve la solucion de una ecuacion cuadrática de la forma ax^2+bx+c=0
/// </summary>
/// <param name="x">valor cuadratico</param>
/// <param name="y">valor lineal</param>
/// <param name="z">valor numerico</param>
/// <returns>devuelve un string con las soluciones</returns>
public static string EcuacionCuadraticaRacional(double x, double y, double z)
{
///verifica que el valor cuadratico no sea 0
if (x == 0)
{
throw new SystemException();
}
else
{
double disc = Math.Pow(y, 2) - 4 * x * z;
///verifica el valor del discriminante que es igual a b^2-4ac.
///si es mayor que 0 devolvera 2 resultados si es 0 devolvera 1 y si es menor devolvera una excepcion
if (disc > 0)
{
double raiz1 = (-y + (Math.Sqrt(disc))) / (2 * x);
double raiz2 = (-y - (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado 1: " + raiz1 + "\nResultado 2: " + raiz2;
return res;
}
else if (disc < 0)
{
throw new InvalidOperationException();
}
else
{
double raiz = (-y + (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado =" + raiz;
return res;
}
}
}
/// <summary>
/// metodo que calcula la solucion de una ecuacion lineal de la forma ax+b=0
/// </summary>
/// <param name="x">valor lineal</param>
/// <param name="y">valor numérico</param>
/// <returns>devuelve la solucion de la ecuacion</returns>
public static double EcuacionLinealRacional(double x, double y)
{
///verifica que el valor lineal no sea 0
if (x == 0)
{
throw new SystemException();
}
else
{
double res = -(y / x);
return res;
}
}
}
}
PARA LOS NUMEROS REALES
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace calculadora
{
/// <summary>
/// Clase que contiene métodos para operar números reales
/// </summary>
class CalculadoraReales
{
/// <summary>
/// Método que suma 2 números reales, usa datos de tipo double debido a que los números reales incluyen decimales
/// </summary>
/// <param name="x">primer número real</param>
/// <param name="y">segundo número real</param>
/// <returns>retorna la suma de 2 números reales</returns>
public static double SumaReal(double x, double y)
{
double suma = x + y;
return suma;
}
/// <summary>
/// Método que resta 2 números reales, usa datos de tipo double debido a que los números reales incluyen decimales
/// </summary>
/// <param name="x">primer número real</param>
/// <param name="y">segundo número real</param>
/// <returns>retorna la resta de 2 números reales</returns>
public static double RestaReal(double x, double y)
{
double Resta = x - y;
return Resta;
}
/// <summary>
/// Método que multiplica 2 números reales, usa datos de tipo double debido a que los números reales incluyen decimales
/// </summary>
/// <param name="x">primer número real</param>
/// <param name="y">segundo número real</param>
/// <returns>retorna la multiplicación de 2 números reales</returns>
public static double MultiplicacionReal(double x, double y)
{
double multi = x * y;
return multi;
}
/// <summary>
/// Método que divide 2 números reales, usa datos de tipo double debido a que los números reales incluyen decimales
/// </summary>
/// <param name="x">primer número real</param>
/// <param name="y">segundo número real</param>
/// <returns>retorna la división de 2 números reales</returns>
public static double DivisionReal(double x, double y)
{
///verifica si el segundo número ingresado es 0 ya que la división por 0 no existe
///si es así retornará la excepción DivideByZeroException
if (y == 0)
{
throw new DivideByZeroException();
}
else
{
double div = x / y;
return div;
}
}
/// <summary>
/// metodo que calcula el porcentaje de un número
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">porcentaje</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double PorcentajeReal(double x, double y)
{
double por = (x / 100) * y;
return por;
}
/// <summary>
/// metodo que calcula el resultado de elevar un numero a una potencia
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">potencia</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double PotenciaReal(double x, double y)
{
double pot = Math.Pow(x, y);
return pot;
}
/// <summary>
/// metodo que calcula el logaritmo de un numero en una base determinada
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">base</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double LogaritmoReal(double x, double y)
{
if (x < 0 || y < 0)
{
throw new SystemException();
}
else
{
double log = Math.Log(x, y);
return log;
}
}
/// <summary>
/// metodo que calcula la raiz de un numero
/// </summary>
/// <param name="x">numero</param>
/// <param name="y">raiz</param>
/// <returns>devuelve un valor con el resultado</returns>
public static double RadicacionReal(double x, double y)
{
///verifica que el numero no sea negativo
if (x < 0)
{
throw new SystemException();
}
else
{
double rad = Math.Pow(x, (1 / y));
return rad;
}
}
/// <summary>
/// metodo que calcula el resultado de elevar 10 a una potencia
/// </summary>
/// <param name="x">potencia</param>
/// <returns>devuelve un numero con el resultado</returns>
public static double PotenciaDiezReal(double x)
{
double pot10 = Math.Pow(10, x);
return pot10;
}
/// <summary>
/// metodo que calcula el seno de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double SenoReal(double x)
{
double sen = Math.Sin(x);
return sen;
}
/// <summary>
/// metodo que calcula el seno hiperbolico de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double SenoHReal(double x)
{
double senh = Math.Sinh(x);
return senh;
}
/// <summary>
/// metodo que calcula el coseno de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double CosenoReal(double x)
{
double cos = Math.Cos(x);
return cos;
}
/// <summary>
/// metodo que calcula el coseno hiperbolico de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double CosenoHReal(double x)
{
double cosh = Math.Cosh(x);
return cosh;
}
/// <summary>
/// metodo que calcula la tangente de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double TangenteReal(double x)
{
double tan = Math.Tan(x);
return tan;
}
/// <summary>
/// metodo que calcula la tangente hiperbolica de un numero
/// </summary>
/// <param name="x">numero</param>
/// <returns>devuelve un dobule que es el seno de un numero</returns>
public static double TangenteHReal(double x)
{
double tanh = Math.Tanh(x);
return tanh;
}
/// <summary>
/// metodo que devuelve la solucion de una ecuacion cuadrática de la forma ax^2+bx+c=0
/// </summary>
/// <param name="x">valor cuadratico</param>
/// <param name="y">valor lineal</param>
/// <param name="z">valor numerico</param>
/// <returns>devuelve un string con las soluciones</returns>
public static string EcuacionCuadraticaReal(double x, double y, double z)
{
///verifica que el valor cuadratico no sea 0
if (x == 0)
{
throw new SystemException();
}
else
{
double disc = Math.Pow(y, 2) - 4 * x * z;
///verifica el valor del discriminante que es igual a b^2-4ac.
///si es mayor que 0 devolvera 2 resultados si es 0 devolvera 1 y si es menor devolvera 2 resultados dentro de los complejos
if (disc > 0)
{
double raiz1 = (-y + (Math.Sqrt(disc))) / (2 * x);
double raiz2 = (-y - (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado 1: " + raiz1 + "\nResultado 2: " + raiz2;
return res;
}
else if (disc < 0)
{
throw new InvalidOperationException();
}
else
{
double raiz = (-y + (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado =" + raiz;
return res;
}
}
}
/// <summary>
/// metodo que calcula la solucion de una ecuacion lineal de la forma ax+b=0
/// </summary>
/// <param name="x">valor lineal</param>
/// <param name="y">valor numérico</param>
/// <returns>devuelve la solucion de la ecuacion</returns>
public static double EcuacionLinealReal(double x, double y)
{
///verifica que el valor lineal no sea 0
if (x == 0)
{
throw new SystemException();
}
else
{
double res = -(y / x);
return res;
}
}
}
}
PARA LOS NUMEROS COMPLEJOS
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace calculadora
{
/// <summary>
/// Clase que contiene métodos para operar números complejos
/// </summary>
class CalculadoraComplejos
{
/// <summary>
/// Método que suma 2 números complejos
/// </summary>
/// <param name="a">Parte real del primer complejo</param>
/// <param name="b">Parte imaginaria del primer complejo</param>
/// <param name="c">Parte real del segundo complejo</param>
/// <param name="d">Parte imaginaria del segundo complejo</param>
/// <returns>Retorna un string que contiene la suma de los 2 números complejos</returns>
public static string SumaComplejo(double a, double b, double c, double d)
{
///creamos un arreglo que contiene el resultado de la suma según la siguiente fórmula:
///(a+bi)+(c+di)=(a+c)+(b+d)i
double[] resultado = new double[] { a+ c, b + d };
///con este if se mejorará la "presentación" del string que contiene el resultado
///si la parte imaginaria es menor a 0 el programa la concatenará sin necesidad de usar ningún símbolo
///para separarlo de la parte real debido debido a que la parte imaginaria estará acompañada de un signo "-" (ejemplo: 2-4i)
///En caso de que la parte imaginaria sea 0 o mayor se concatenará con un signo "+" a la parte real (ejemplo: 2+3i)
if (resultado[1] < 0)
{
///la sentencia string.join imprime en una sola linea los elementos de un arreglo (en este caso el arreglo resultado)
///y los separa con cualquier texto que uno use dentro de las comillas
string suma = string.Join("", resultado);
return suma;
}
else
{
string suma = string.Join("+", resultado);
return suma;
}
}
/// <summary>
/// Método que resta 2 números complejos
/// </summary>
/// <param name="a">Parte real complejo 1</param>
/// <param name="b">Parte imaginaria complejo 1</param>
/// <param name="c">Parte real complejo 2</param>
/// <param name="d">Parte imaginaria complejo 2</param>
/// <returns>retorna un string que contiene el resultado de la resta de 2 números complejos</returns>
public static string RestaComplejo(double a, double b, double c, double d)
{
///creamos un arreglo que contiene el resultado de la resta según la siguiente fórmula:
///(a+bi)-(c+di)=(a-c)+(b-d)i
double[] resultado = new double[] {a - c, b - d };
///if para imprimir el resultado según su parte imaginaria (ver el if del metodo suma complejo)
if (resultado[1] < 0)
{
string resta = string.Join("", resultado);
return resta;
}
else
{
string resta = string.Join("+", resultado);
return resta;
}
}
/// <summary>
/// Método que multiplica 2 números complejos
/// </summary>
/// <param name="a">Parte real complejo 1</param>
/// <param name="b">Parte imaginaria complejo 1</param>
/// <param name="c">Parte real complejo 2</param>
/// <param name="d">Parte imaginaria complejo2</param>
/// <returns></returns>
public static string MultiplicacionComplejo(double a, double b, double c, double d)
{
///Creamos un arreglo que contiene el resultado de la multiplicación según la siguiente fórmula:
///(a+bi)*(c+di)=(ac-bd)+(ad+bc)i
double[] resultado = new double[] { (a * c) - (b * d), (a * d) + (b* c) };
///if para imprimir el resultado según su parte imaginaria (ver el if del metodo suma complejo)
if (resultado[1] < 0)
{
string multi = string.Join("", resultado);
return multi;
}
else
{
string multi = string.Join("+", resultado);
return multi;
}
}
public static string DivisionComplejo(double a, double b, double c, double d)
{
///verifica si el segundo complejo ingresado tiene 0 en su parte real o imaginaria ya que estos no pueden ser 0
///si es así retornará la excepción DivideByZeroException
if (c == 0 || d == 0)
{
throw new DivideByZeroException();
}
else
///si el segundo numero complejo no contiene 0 creará un arreglo con el resultado de la división usando la siguiente fórmula
///{[(a*c)+(b*d)]/[(c^2+d^2)]}+{[(b*c)-(a*d)]/[(c^2+d^2)]}i
///la sentencia Math.Pow(base, potencia) se usa para elevar c y d al cuadrado
{
double[] resultado = new double[] { ((a * c) + (b * d)) / (Math.Pow(c, 2) + Math.Pow(d, 2)), ((b * c) - (a * d)) / (Math.Pow(c, 2) + Math.Pow(d, 2)) };
///if para imprimir el resultado según su parte imaginaria (ver el if del metodo suma complejo)
if (resultado[1] < 0)
{
string div = string.Join("", resultado);
return div;
}
else
{
string div = string.Join("+", resultado);
return div;
}
}
}
/// <summary>
/// metodo que devuelve la solucion de una ecuacion cuadrática de la forma ax^2+bx+c=0
/// </summary>
/// <param name="x">valor cuadratico</param>
/// <param name="y">valor lineal</param>
/// <param name="z">valor numerico</param>
/// <returns>devuelve un string con las soluciones</returns>
public static string EcuacionCuadraticaComplejo(double x, double y, double z)
{
double disc = Math.Pow(y, 2) - 4 * x * z;
if (disc > 0)
{
double raiz1 = (-y + (Math.Sqrt(disc))) / (2 * x);
double raiz2 = (-y - (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado 1: " + raiz1 + "\nResultado 2: " + raiz2;
return res;
}
else if (disc < 0)
{
disc = disc * -1;
double entero = -y / 2 * x;
double imaginario = Math.Sqrt(disc) / 2 * x;
string res = "\nResultado 1: " + entero + "+" + imaginario + "i\nResultado 2: " + entero + "-" + imaginario + "i";
return res;
}
else
{
double raiz = (-y + (Math.Sqrt(disc))) / (2 * x);
string res = "\nResultado =" + raiz;
return res;
}
}
}
}
