naturales
enteros
racionales
reales
complejos
para cada una de estos cases hay cuatro métodos
suma
resta
multiplicación
división
como se mostrara a continuación
para los números 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 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 división de los 2 números naturales</returns>
public static int DivisionNatural(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 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
{
int div = x / y;
return div;
}
}
}
}
para los números 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 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 división de los 2 números enteros</returns>
public static int DivisionEntero(int x, int 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
{
int div = x / y;
return div;
}
}
}
}
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;
}
}
}
}
para los números 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;
}
}
}
}
para los números 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;
}
}
}
}
}
