Integrantes:
Sergio Andrés Sepúlveda
Sthefany Blanco
Juan David Franco
¿que se ha hecho?
Para el segundo avance de nuestra calculadora científica se adicionaron las operaciones: %, xy , logxy, y√x, n!, 10x, sen(x), cos(x), tan(x), senh(x), cosh(x), tanh(x), en los dominios donde aplicaban las operaciones, y tambien se imprlementó la solucion de ecuaciones lineales y cuadráticas.
además se corrigieron algunas excepciones (mayoritariamente en los números naturales y enteros) donde al arrojar un resultado decimal se separaba la solución por su parte decimal y su parte entera, ahora arrojará una excepción de tipo InvalidOperationException
¿qué falta?
falta realizar las pruebas unitarias tanto del flujo principal como alternos de los distintos métdodos que componen nuestras clases
Diagrama de clase:
Código Fuente:
Clase CalculadoraNumerosNaturales
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;
}
}
}
}
}
}
}
Clase CalculadoraNumerosEnteros
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;
}
}
}
}
}
Clase CalculadoraNumerosRacionales
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;
}
}
}
}
Clase CalculadoraNumerosReales
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;
}
}
}
}
Clase CalculadoraNumerosComplejos
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;
}
}
}
}
Clase Main
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace calculadora
{
/// <summary>
/// Clase principal con los menús para operar los números
/// </summary>
class Program
{
static void Main(string[] args)
{ ///variables para los operadores
///naturales y enteros
int a, b;
///racionales, reales y complejos
double c, d, x, y;
///Menú para seleccionar el dominio de números
Console.WriteLine("Seleccione el dominio de números para trabajar:\n1.Naturales\n2.Enteros\n3.Racionales\n4.Reales\n5.Complejos\n6.Salir\n");
int menu = int.Parse(Console.ReadLine());
switch (menu)
{
///menu números naturales
case 1:
///submenú para seleccionar operación
Console.WriteLine("\nSeleccione la operación:\n1.Suma\n2.Resta\n3.Multiplicación\n4.División\n5.Porcentaje\n6.Potencia\n7.Radicacion\n8.Factorial\n9.Potencia en base 10\n10.Ecuacion cuadratica\n11.Salir\n");
int menunatural = int.Parse(Console.ReadLine());
switch (menunatural)
{
case 1:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nSuma = " + CalculadoraNaturales.SumaNatural(a, b));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 2:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nResta = " + CalculadoraNaturales.RestaNatural(a, b));
}
catch (InvalidOperationException e)
{
Console.WriteLine("\nLa operacion da como resultado un número negativo lo que es inválido en los naturales");
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 3:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nMultiplicación = " + CalculadoraNaturales.MultiplicacionNatural(a, b));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 4:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nDivisión = " + CalculadoraNaturales.DivisionNatural(a, b));
}
catch (DivideByZeroException e)
{
Console.WriteLine("\nNo existe la división por 0");
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 5:
Console.WriteLine("\nEscriba el porcentaje que quiere hallar: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el valor al que le quiere hallar porcentaje: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nPorcentaje = " + CalculadoraNaturales.PorcentajeNatural(a, b));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 6:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nPotencia = " + CalculadoraNaturales.PotenciaNatural(a, b));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 7:
Console.WriteLine("\nEscriba el valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba la raiz: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nRaiz " + b + " de " + a + "= " + CalculadoraNaturales.RadicacionNatural(a, b));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 8:
Console.WriteLine("\nEscriba el valor: ");
a = int.Parse(Console.ReadLine());
try
{
Console.WriteLine(a + "! Factorial= " + CalculadoraNaturales.Factorial(a));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 9:
Console.WriteLine("\nEscriba el valor: ");
a = int.Parse(Console.ReadLine());
try
{
Console.WriteLine(a + " potencia en base 10= " + CalculadoraNaturales.PotenciaDiezNatural(a));
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos");
}
break;
case 10:
Console.WriteLine("\nIntroduzca el valor cuadratico: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor lineal: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
x = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: " + c + "X^2+" + d + "X+" + x + "=0");
try
{
Console.WriteLine("\nSoluciones: " + CalculadoraNaturales.EcuacionCuadraticaNatural(c, d, x));
}
catch (InvalidOperationException e)
{
Console.WriteLine("La solucion no se encuentra en los naturales");
}
catch (SystemException e)
{
Console.WriteLine("\nEn los números naturales no entran los numeros negativos ni el valor cuadratico puede ser 0");
}
break;
case 11:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 11");
break;
}
break;
///menu números enteros
case 2:
///submenú para seleccionar la operación
Console.WriteLine("\nSeleccione la operación:\n1.Suma\n2.Resta\n3.Multiplicación\n4.División\n5.Porcentaje\n6.Potencia\n7.Radicacion\n8.Potencia en base 10\n9.Ecuacion Lineal\n10.Ecuacion cuadratica\n11.Salir\n");
int menuentero = int.Parse(Console.ReadLine());
switch (menuentero)
{
case 1:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
Console.WriteLine("\nSuma = " + CalculadoraEnteros.SumaEntero(a,b));
break;
case 2:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
Console.WriteLine("\nResta = " + CalculadoraEnteros.RestaEntero(a, b));
break;
case 3:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
Console.WriteLine("\nMultiplicación = " + CalculadoraEnteros.MultiplicacionEntero(a, b));
break;
case 4:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nDivisión = " + CalculadoraEnteros.DivisionEntero(a, b));
}
catch (DivideByZeroException e)
{
Console.WriteLine("\nNo existe la división por 0");
}
break;
case 5:
Console.WriteLine("\nEscriba el porcentaje que quiere hallar: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el valor al que le quiere hallar porcentaje: ");
b = int.Parse(Console.ReadLine());
Console.WriteLine("\nPorcentaje = " + CalculadoraEnteros.PorcentajeEntero(a, b));
break;
case 6:
Console.WriteLine("\nEscriba el primer valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
b = int.Parse(Console.ReadLine());
Console.WriteLine("\nPotencia = " + CalculadoraEnteros.PotenciaEntero(a, b));
break;
case 7:
Console.WriteLine("\nEscriba el valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba la raiz: ");
b = int.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nRaiz " + b + " de " + a + "= " + CalculadoraEnteros.RadicacionEntero(a, b));
}
catch (SystemException e)
{
Console.WriteLine("\nUna raiz de un numero negativo da como resultado un numero complejo que no esta entre los enteros");
}
break;
case 8:
Console.WriteLine("\nEscriba el valor: ");
a = int.Parse(Console.ReadLine());
Console.WriteLine(a + " potencia en base 10= " + CalculadoraEnteros.PotenciaDiezEntero(a));
break;
case 9:
Console.WriteLine("\nIntroduzca el valor lineal");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: "+c+"X"+d+"=0");
try
{
Console.WriteLine("\n Solución: "+ CalculadoraEnteros.EcuacionLinealEntero(c,d));
}
catch (InvalidOperationException e)
{
Console.WriteLine("La solucion esta fuera de los enteros");
}
catch (SystemException e)
{
Console.WriteLine("El valor lineal no puede ser 0");
}
break;
case 10:
Console.WriteLine("\nIntroduzca el valor cuadratico: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor lineal: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
x = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: " + c + "X^2+" + d + "X+" + x + "=0");
try
{
Console.WriteLine("\nSoluciones: " + CalculadoraEnteros.EcuacionCuadraticaEntero(c, d, x));
}
catch (InvalidOperationException e)
{
Console.WriteLine("La solucion no se encuentra en los enteros");
}
catch (SystemException e)
{
Console.WriteLine("El valor cuadratico no puede ser 0");
}
break;
case 11:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 11");
break;
}
break;
///menu números racionales
case 3:
///Submenú para seleccionar la operación
Console.WriteLine("\nSeleccione la operación:\n1.Suma\n2.Resta\n3.Multiplicación\n4.División\n5.Porcentaje\n6.Potencia\n7.Logaritmo\n8.Radical\n9.Potencia en base 10\n10.Trigonometricas\n11.Ecuacion lineal\n12.Ecuacion cuadratica\n13.Salir\n");
int menuracional = int.Parse(Console.ReadLine());
switch (menuracional)
{
case 1:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nSuma = " + CalculadoraRacionales.SumaRacional(c, d));
break;
case 2:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nResta = " + CalculadoraRacionales.RestaRacional(c, d));
break;
case 3:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nMultiplicación = " + CalculadoraRacionales.MultiplicacionRacional(c, d));
break;
case 4:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nDivisión = " + CalculadoraRacionales.DivisionRacional(c, d));
}
catch (DivideByZeroException e)
{
Console.WriteLine("\nNo existe la división por 0");
}
break;
case 5:
Console.WriteLine("\nEscriba el porcentaje que quiere hallar: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el valor al que le quiere hallar porcentaje: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nPorcentaje = \n" + CalculadoraRacionales.PorcentajeRacional(c, d));
break;
case 6:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nPotencia = " + CalculadoraRacionales.PotenciaRacional(c, d));
break;
case 7:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba la base: ");
d = double.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nLogaritmo en base " + d + " de " + c + "= " + CalculadoraRacionales.LogaritmoRacional(c, d));
}
catch (SystemException e)
{
Console.WriteLine("\nNo existen logaritmos de numeros iguales o menores a 0 ni de bases iguales a 0 o menores");
}
break;
case 8:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba la raiz: ");
d = double.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nRaiz " + d + " de " + c + "= " + CalculadoraRacionales.RadicacionRacional(c, d));
}
catch (SystemException e)
{
Console.WriteLine("\nUna raiz de un numero negativo da como resultado un numero complejo que no esta entre los racionales");
}
break;
case 9:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine(c + " potencia en base 10= " + CalculadoraRacionales.PotenciaDiezRacional(c));
break;
case 10:
Console.WriteLine("\nSeleccione la operacion:\n1.Seno\n2.Seno hiperbolico\n3.Coseno\n4.Coseno hiperbolico\n5.Tangente\n6.Tangente hiperbolica\n7.Salir\n");
int menutrigonometricoracional = int.Parse(Console.ReadLine());
switch (menutrigonometricoracional)
{
case 1:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Sen("+c+")="+CalculadoraRacionales.SenoRacional(c));
break;
case 2:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Senh("+c+")="+CalculadoraRacionales.SenoHRacional(c));
break;
case 3:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Cos("+c+")="+CalculadoraRacionales.CosenoRacional(c));
break;
case 4:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Cosh("+c+")="+CalculadoraRacionales.CosenoHRacional(c));
break;
case 5:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Tan("+c+")="+CalculadoraRacionales.TangenteRacional(c));
break;
case 6:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Tanh("+c+")="+CalculadoraRacionales.TangenteHRacional(c));
break;
case 7:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 7");
break;
}
break;
case 11:
Console.WriteLine("\nIntroduzca el valor lineal");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: "+c+"X"+d+"=0");
try
{
Console.WriteLine("\n Solución: "+ CalculadoraRacionales.EcuacionLinealRacional(c,d));
}
catch (SystemException e)
{
Console.WriteLine("El valor lineal no puede ser 0");
}
break;
case 12:
Console.WriteLine("\nIntroduzca el valor cuadratico: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor lineal: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
x = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: " + c + "X^2+" + d + "X+" + x + "=0");
try
{
Console.WriteLine("\nSoluciones: " + CalculadoraRacionales.EcuacionCuadraticaRacional(c, d, x));
}
catch (InvalidOperationException e)
{
Console.WriteLine("La solucion no se encuentra en los racionales");
}
catch (SystemException e)
{
Console.WriteLine("El valor cuadratico no puede ser 0");
}
break;
case 13:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 13");
break;
}
break;
/// menú números reales
case 4:
///Submenú para seleccionar la operación
Console.WriteLine("\nSeleccione la operación:\n1.Suma\n2.Resta\n3.Multiplicación\n4.División\n5.Porcentaje\n6.Potencia\n7.Logaritmo\n8.Radical\n9.Potencia en base 10\n10.Trigonometricas\n11. Ecuacion lineal\n12.Ecuacion cuadratica\n13.Salir\n");
int menureal = int.Parse(Console.ReadLine());
switch (menureal)
{
case 1:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nSuma = " + CalculadoraReales.SumaReal(c, d));
break;
case 2:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nResta = " + CalculadoraReales.RestaReal(c, d));
break;
case 3:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nMultiplicación = " + CalculadoraReales.MultiplicacionReal(c, d));
break;
case 4:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nDivisión = " + CalculadoraReales.DivisionReal(c, d));
}
catch (DivideByZeroException e)
{
Console.WriteLine("\nNo existe la división por 0");
}
break;
case 5:
Console.WriteLine("\nEscriba el porcentaje que quiere hallar: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el valor al que le quiere hallar porcentaje: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nPorcentaje = \n" + CalculadoraReales.PorcentajeReal(c, d));
break;
case 6:
Console.WriteLine("\nEscriba el primer valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el segundo valor: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nPotencia = " + CalculadoraReales.PotenciaReal(c, d));
break;
case 7:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba la base: ");
d = double.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nLogaritmo en base " + d + " de " + c + "= " + CalculadoraReales.LogaritmoReal(c, d));
}
catch (SystemException e)
{
Console.WriteLine("\nNo existen logaritmos de numeros iguales o menores a 0 ni de bases iguales a 0 o menores");
}
break;
case 8:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba la raiz: ");
d = double.Parse(Console.ReadLine());
try
{
Console.WriteLine("\nRaiz "+d+" de "+c+"= "+CalculadoraReales.RadicacionReal(c,d));
}
catch (SystemException e)
{
Console.WriteLine("en los reales no existen raices negativas");
}
break;
case 9:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine(c + " potencia en base 10= " + CalculadoraReales.PotenciaDiezReal(c));
break;
case 10:
Console.WriteLine("\nSeleccione la operacion:\n1.Seno\n2.Seno hiperbolico\n3.Coseno\n4.Coseno hiperbolico\n5.Tangente\n6.Tangente hiperbolica\n7.Salir\n");
int menutrigonometricoracional = int.Parse(Console.ReadLine());
switch (menutrigonometricoracional)
{
case 1:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Sen(" + c + ")=" + CalculadoraReales.SenoReal(c));
break;
case 2:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Senh(" + c + ")=" + CalculadoraReales.SenoHReal(c));
break;
case 3:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Cos(" + c + ")=" + CalculadoraReales.CosenoReal(c));
break;
case 4:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Cosh(" + c + ")=" + CalculadoraReales.CosenoHReal(c));
break;
case 5:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Tan(" + c + ")=" + CalculadoraReales.TangenteReal(c));
break;
case 6:
Console.WriteLine("\nEscriba el valor: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("Tanh(" + c + ")=" + CalculadoraReales.TangenteHReal(c));
break;
case 7:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 7");
break;
}
break;
case 11:
Console.WriteLine("\nIntroduzca el valor lineal");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: " + c + "X" + d + "=0");
try
{
Console.WriteLine("\n Solución: " + CalculadoraReales.EcuacionLinealReal(c, d));
}
catch (SystemException e)
{
Console.WriteLine("El valor lineal no puede ser 0");
}
break;
case 12:
Console.WriteLine("\nIntroduzca el valor cuadratico: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor lineal: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
x = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: " + c + "X^2+" + d + "X+" + x + "=0");
try
{
Console.WriteLine("\nSoluciones: " + CalculadoraReales.EcuacionCuadraticaReal(c, d, x));
}
catch (InvalidOperationException e)
{
Console.WriteLine("La solucion no se encuentra en los racionales");
}
catch (SystemException e)
{
Console.WriteLine("El valor cuadratico no puede ser 0");
}
break;
case 13:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 13");
break;
}
break;
/// menu numeros complejos
case 5:
Console.WriteLine("\nEscriba valor real del primer complejo ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el valor imaginario del primer complejo ");
d = double.Parse(Console.ReadLine());
if (d < 0)
{
Console.WriteLine("\nprimer complejo: " + c + d + "i\n");
}
else
{
Console.WriteLine("\nprimer complejo: " + c + "+" + d + "i\n");
}
Console.WriteLine("\nEscriba valor real del segundo complejo ");
x = double.Parse(Console.ReadLine());
Console.WriteLine("\nEscriba el valor imaginario del segundo complejo ");
y = double.Parse(Console.ReadLine());
if (y < 0)
{
Console.WriteLine("\nsegundo complejo: " + x + y + "i\n");
}
else
{
Console.WriteLine("\nsegundo complejo: " + x + "+" + y + "i\n");
}
///Submenú para seleccionar la operación
Console.WriteLine("\nSeleccione la operación:\n1.Suma\n2.Resta\n3.Multiplicación\n4.División\n5.Salir\n");
int menucomplejo = int.Parse(Console.ReadLine());
switch (menucomplejo)
{
case 1:
Console.WriteLine("\nSuma = " + CalculadoraComplejos.SumaComplejo(c, d, x, y) + "i");
break;
case 2:
Console.WriteLine("\nResta = " + CalculadoraComplejos.RestaComplejo(c, d, x, y) + "i");
break;
case 3:
Console.WriteLine("\nMultiplicación = " + CalculadoraComplejos.MultiplicacionComplejo(c, d, x, y) + "i");
break;
case 4:
try
{
Console.WriteLine("\nDivisión = " + CalculadoraComplejos.DivisionComplejo(c, d, x, y) + "i");
}
catch (DivideByZeroException e)
{
Console.WriteLine("\nNo existe la división por 0");
}
break;
case 5:
Console.WriteLine("\nIntroduzca el valor cuadratico: ");
c = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor lineal: ");
d = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduzca el valor entero: ");
x = double.Parse(Console.ReadLine());
Console.WriteLine("\nEcuación: " + c + "X^2+" + d + "X+" + x + "=0");
Console.WriteLine("\nSoluciones: " + CalculadoraComplejos.EcuacionCuadraticaComplejo(c, d, x));
break;
case 6:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 6");
break;
}
break;
case 6:
System.Environment.Exit(0);
break;
default:
Console.WriteLine("\nEscriba un numero de 1 a 6");
break;
}
Console.ReadLine();
}
}
}
