Metodos Math

Nombre del Estudiante: Orbin Daniel Morales López
Número de Cuenta: 1220207
Nombre del Catedrático/a: Lic. Eldrin Salomón Mejía Guzmán
Sección: 1
Horario de Clase: 6:10 PM – 9:10 PM
Asignatura: Programación I
Fecha de Elaboración: 14/09/2022
1
Métodos Math o Matemáticos en Microsoft Visual C#
 Método Math.Abs: Devuelve el valor absoluto de un número

especificado.
La Sintaxis del Método Math.Abs es la siguiente:
public static decimal Abs (decimal val);
 Ejemplo:
// C# Program to illlustrate the
// Math.Abs(Decimal) Method
using System;
class Geeks {
// Main Method
public static void Main()
// Taking decimal values
decimal[] deci = {Decimal.MinValue, 45.14M, 0M,
-17.47M, Decimal.MaxValue};
// using foreach loop
foreach(decimal value in deci)
// Displaying the result
2
Console.WriteLine("Absolute value of {0} = {1}",
value,
Math.Abs(value));
 Método Math.Acos: Devuelve el ángulo cuyo coseno es el número

especificado.
La Sintaxis del Método Math.Acos es la siguiente:
public static double Acos(double num)
 Ejemplo:
// C# program to demonstrate working
// of Math.Acos() method
using System;
class Geeks {
// Main Method
public static void Main(String[] args)
double a = Math.PI;
// using Math.Acos() method
Console.WriteLine(Math.Acos(a));
// argument is greater than 1
3
Console.WriteLine(Math.Acos(2));
Console.WriteLine(Math.Acos(0.3584));
double d = 0.0;
double e = -0.0;
double posi = Double.PositiveInfinity;
double nega = Double.NegativeInfinity;
double nan = Double.NaN;
// Input positive zero
// Output 1.5707963267949
double res = Math.Acos(d);
// converting to degree
// i.e output will be 90 degree
double rest = res * (180 / Math.PI);
Console.WriteLine(rest);
// Input negative zero
// Output 1.5707963267949
Console.WriteLine(Math.Acos(e));
// input PositiveInfinity
4
// Output NaN
Console.WriteLine(Math.Acos(posi));
// input NegativeInfinity
// Output NaN
Console.WriteLine(Math.Acos(nega));
// input NaN
// Output NaN
Console.WriteLine(Math.Acos(nan));
 Método Math.Acosh: Devuelve el ángulo cuyo coseno hiperbólico es el

número especificado.
La Sintaxis del Método Math.Acosh es la siguiente:
public static float Acosh (float x);
 Ejemplo:
// C# program to demonstrate the
// MathF.Acosh(Single) Method
using System;
class GFG {
// Main Method
5
{
// Declaring and initializing value
float value = 2.5f;
// getting hyperbolic arc-cosine value
// using Acosh() method
float result = MathF.Acosh(value);
// Display the value
Console.WriteLine("Angle is {0}", result);
 Método Math.Asin: Devuelve el ángulo cuyo seno es el número

especificado.
La Sintaxis del Método Math.Asin es la siguiente:
public static double Asin(double num)
 Ejemplo:
// of Math.Asin() method
using System;
class Geeks {
// Main Method
6
double a = Math.PI;
// using Math.Asin() method
Console.WriteLine(Math.Asin(a));
// argument is greater than 1
Console.WriteLine(Math.Asin(2));
Console.WriteLine(Math.Asin(0.3584));
double d = 0.0;
double e = -0.0;
// Output 0
double res = Math.Asin(d);
// converting to degree
// i.e. output is 0 degree
7
double rest = res * (180 / Math.PI);
Console.WriteLine(rest);
// Output 0
Console.WriteLine(Math.Asin(e));
// Output NaN
Console.WriteLine(Math.Asin(posi));
// Output NaN
Console.WriteLine(Math.Asin(nega));
// input NaN
// Output NaN
Console.WriteLine(Math.Asin(nan));
 Método Math.Asinh: El método Math.Asinh se utiliza para devolver el

arco-seno hiperbólico de un valor de coma flotante.
La Sintaxis del Método Math.Asinh es la siguiente:
Math.Asinh(Double d)
 Ejemplo:
8
// MathF.Asinh(Single) Method
using System;
class GFG {
// Main Method
// Declaring and initializing value
float value = 1.5f;
// getting hyperbolic arc-cosine value
// using Asinh() method
float result = MathF.Asinh(value);
// Display the value
Console.WriteLine("Angle is {0}", result);
 Método Math.Atan: Devuelve el ángulo cuya tangente corresponde al

La Sintaxis del Método Math.Atan es la siguiente:
public static double Atan(double num)
9
 Ejemplo
// of Math.Atan() method
using System;
class Geeks {
// Main Method
public static void Main(String []args)
double a = Math.PI;
// using Math.Atan() method
Console.WriteLine(Math.Atan(a));
double d = 0.0;
double e = -0.0;
Console.WriteLine(Math.Atan(1));
10
// Output positive zero
Console.WriteLine(Math.Atan(d));
// Output positive zero
Console.WriteLine(Math.Atan(e));
// Output 1.5707963267949
Console.WriteLine(Math.Atan(posi));
// Output -1.5707963267949
Console.WriteLine(Math.Atan(nega));
// input NaN
// Output NaN
Console.WriteLine(Math.Atan(nan));
 Método Math.Atan2: Devuelve el ángulo cuya tangente es el cociente

de dos números especificados.
La Sintaxis del Método Math.Atan2 es la siguiente:
public static double Atan2(double value1, double value2)
 Ejemplo:
11
// Math.Atan2() Method when point
// lies in first quadrant
using System;
class Geeks {
// Main method
// using Math.Atan2() Method &
// converting result into degree
Console.Write(Math.Atan2(10, 10) * (180 / Math.PI));
 Método Math.Atanh: Devuelve el ángulo cuya tangente hiperbólica es

el número especificado.
La Sintaxis del Método Math.Atanh es la siguiente:
Math.Atanh(Double d);
 Ejemplo:
using System;
class Example {
static void Main(string[] args) {
Double d, result;
12
d = Double.NegativeInfinity;
result = Math.Atanh(d);
Console.WriteLine($"Atanh({d}) = {result} radians.");
d = -5;
d = -1;
d = 0;
d = 1;
d = 5;
13
d = Double.PositiveInfinity;
 Método Math.BigMul: En C#, BigMul() es un método de clase de

método. Este método se utiliza para calcular el producto completo de
dos números de 32 bits.
La Sintaxis del Método Math.BigMul es la siguiente:
public static long BigMul(int a, int b);
 Ejemplo:
// Math.BigMul() method
using System;
namespace ConsoleApplication1 {
class Geeks {
// Main Method
static void Main(string[] args)
// defining two variable of type
// System.Int32
Int32 x1 = 233232322;
14
Int32 x2 = 189222338;
// Using BigMul( ) method and storing
// result into a long(Int64) variable
long product = Math.BigMul(x1, x2);
// Getting the output
Console.WriteLine("The product of the two numbers is " +

product);
 Método Math.BitDecrement: Devuelve el siguiente valor más pequeño

menor que x.
La Sintaxis del Método Math.BitDecrement es la siguiente:
Math.BitDecrement(Double x);
 Ejemplo:
using System;
class Example {
Double x, result;
x = 12.56;
result = Math.BitDecrement(x);
15
Console.WriteLine($"BitDecrement({x}) = {result}");
x = 10;
result = Math.BitDecrement(x);
Console.WriteLine($"BitDecrement({x}) = {result}");
 Método Math.BitIncrement: Devuelve el siguiente valor más grande

mayor que x.
La Sintaxis del Método Math.BitIncrement es la siguiente:
Math.BitIncrement(Double x);
 Ejemplo:
using System;
class Example {
Double x, result;
x = 12.56;
result = Math.BitIncrement(x);
Console.WriteLine($"BitIncrement({x}) = {result}");
x = 10;
result = Math.BitIncrement(x);
Console.WriteLine($"BitIncrement({x}) = {result}");
16
}
 Método Math.Cbrt: Devuelve la raíz cúbica de un número especificado.
La Sintaxis del Método Math.Cbrt es la siguiente:
Math.Cbrt(Double d);
 Ejemplo:
using System;
class Example {
Double d, result;
d = 2;
result = Math.Cbrt(d);
Console.WriteLine($"Cbrt({d}) = {result}");
d = 3;
d = 4;
17
d = 27;
d = 64;
d = 0.008;
d = -27;
d = Double.NegativeInfinity;
d = Double.PositiveInfinity;
}
18
 Método Math.Ceiling: Devuelve el menor valor integral mayor o igual
que el número especificado.
La Sintaxis del Método Math.Ceiling es la siguiente:
public static decimal Ceiling(decimal d);
 Ejemplo:
// C# program to illustrate the
// Math.Ceiling(Decimal) function
using System;
class SudoPlacement {
// Main method
static void Main()
// Input decimal value.
decimal decim_n1 = 2.10M;
decimal decim_n2 = -99.90M;
decimal decim_n3 = 33.001M;
// Calculate Ceiling values by
// Using Math.Ceiling() function
decimal ceil_t1 = Math.Ceiling(decim_n1);
19
// Print First values and Ceiling
Console.WriteLine("Input Value = " + decim_n1);
Console.WriteLine("Ceiling value = " + ceil_t1);
// Print Second values and Ceiling
// Print third values and Ceiling
 Método Math.Clamp: El método C# Clamp() devuelve el valor fijado al

rango inclusivo de mínimo y máximo.
La Sintaxis del Método Math.Clamp es la siguiente:
Math.Clamp(Byte value, Byte min, Byte max);
 Ejemplo:
using System;
class MyProgram {
Console.WriteLine("Math.Clamp(25, 50, 100): "+
Math.Clamp(25, 50, 100));
20
Console.WriteLine("Math.Clamp(25, 0, 50): "+
Math.Clamp(25, 0, 50));
Console.WriteLine("Math.Clamp(25, -25, 0): "+
Math.Clamp(25, -25, 0));
 Método Math.CopySign: Devuelve un valor con la magnitud de x y el

signo de y.
La Sintaxis del Método Math.CopySign es la siguiente:
Math.CopySign(Double x, Double y);
 Ejemplo:
using System;
class Example {
Double x, y, result;
x = 2;
y = -8;
result = Math.CopySign(x, y);
Console.WriteLine($"CopySign({x}, {y}) = {result}");
x = 2;
y = 8;
21
x = -2;
y = 8;
 Método Math.Cos: Devuelve el coseno del ángulo especificado.
La Sintaxis del Método Math.Cos es la siguiente:
public static double Cos(double num);
 Ejemplo:
// Math.Cos() method
using System;
class Geeks {
// Main Method
double a = 70;
// converting value to radians
22
double b = (a * (Math.PI)) / 180;
// using method and displaying result
Console.WriteLine(Math.Cos(b));
a = 50;
b = (a * (Math.PI)) / 180;
a = 73;
b = (a * (Math.PI)) / 180;
a = 77;
b = (a * (Math.PI)) / 180;
23
 Método Math.Cosh: Devuelve el coseno hiperbólico del ángulo

especificado.
La Sintaxis del Método Math.Cosh es la siguiente:
public static double Cosh(double num);
 Ejemplo:
// Math.Cosh()
using System;
class GFG {
// Main Method
double num1 = 60.0, num2 = 0.0, num3 = 1.0;
// It returns the hyperbolic cosine of
// specified angle in radian
double coshvalue = Math.Cosh(num1);
Console.WriteLine("The cosh of num1 = " + coshvalue);
24
coshvalue = Math.Cosh(num2);
coshvalue = Math.Cosh(num3);
 Método Math.DivRem: Calcula el cociente de dos números y devuelve

también el resto de la división como parámetro de salida.
La Sintaxis del Método Math.DivRem es la siguiente:
public static int DivRem(int dividend, int divisor, int result);
 Ejemplo:
// of Math.DivRem(Int32, Int32, Int32)
using System;
class DivRemGeeks {
// Main method
static void Main()
// Input +ve dividend and divisor number
int dividend_A = 9845324;
int divisor_A = 7;
25
// Input negative dividend and divisor number
int dividend_B = -99999;
int divisor_B = 2;
int result_1;
int result_2;
// Using the MATH.DivRem() Method
int quotient_ONE = Math.DivRem(dividend_A, divisor_A, out

result_1);
int quotient_TWO = Math.DivRem(dividend_B, divisor_B, out

result_2);
// Print Result
Console.WriteLine(quotient_ONE);
Console.WriteLine(result_1);
Console.WriteLine(quotient_TWO);
Console.WriteLine(result_2);
 Método Math.Exp: Devuelve e elevado a la potencia especificada.
La Sintaxis del Método Math.Exp es la siguiente:
public static double Exp (double num);
 Ejemplo:
26
// C# Program to illustrate the
// Math.Exp(Double) Method
using System;
class Geeks {
// Main Method
// using the method
Console.WriteLine(Math.Exp(10.0));
 Método Math.Floor: Devuelve el mayor valor integral menor o igual que

el número especificado.
La Sintaxis del Método Math.Floor es la siguiente:
public static decimal Floor(decimal d);
 Ejemplo:
// Math.Floor(Decimal) function
using System;
27
public class GFG {
// Main method
static public void Main()
// Different numbers list to find
// its floor values
Console.WriteLine(Math.Floor(0.2018));
Console.WriteLine(Math.Floor(-0.2));
Console.WriteLine(Math.Floor(34.67M));
 Método Math.FusedMultiplyAdd: Devuelve (x * y) + z, redondeado

como una operación ternaria.
La Sintaxis del Método Math.FusedMultiplyAdd es la siguiente:
Math.FusedMultiplyAdd(Double x, Double y, Double z);
 Ejemplo:
using System;
class Example {
28
Double x, y, z, result;
x = 2;
y = 3;
z = 1;
result = Math.FusedMultiplyAdd(x, y, z);
Console.WriteLine($"FusedMultiplyAdd({x}, {y}, {z}) = {result}");
x = 10;
y = 5;
z = 3;
result = Math.FusedMultiplyAdd(x, y, z);
Console.WriteLine($"FusedMultiplyAdd({x}, {y}, {z}) = {result}");
 Método Math.IEEERemainder: Devuelve el resto de la división de dos

números especificados.
La Sintaxis del Método Math.IEEERemainder es la siguiente:
public static double IEEERemainder (double a, double b);
 Ejemplo:
// Math.IEEERemainder() Method
using System;
class Geeks
29
{
// method to calculate the remainder
private static void DisplayRemainder(double num1, double num2)
var calculation = $"{num1} / {num2} = ";
// calculating IEEE Remainder
var ieeerem = Math.IEEERemainder(num1, num2);
// using remainder operator
var rem_op = num1 % num2;
Console.WriteLine($"{calculation,-16} {ieeerem,18} {rem_op,20}");
// Main Method
Console.WriteLine($"{"IEEERemainder",35} {"Remainder Operator",20}");
30
// calling the method
DisplayRemainder(0, 1);
DisplayRemainder(-4, 8);
DisplayRemainder(-1, -0);
DisplayRemainder(18.52, 2);
DisplayRemainder(42.26, 4.2);
 Método Math.ILogB: Devuelve el logaritmo de entero en base 2 de un

La Sintaxis del Método Math.ILogB es la siguiente:
Math.ILogB(Double x);
 Ejemplo:
using System;
class Example {
Double x;
Double result;
x = 2;
result = Math. ILogB(x);
Console.WriteLine($"ILogB({x}) = {result}");
31
x = 3;
x = 4;
 Método Math.Log: En C#, Math.Log() es un método de clase Math. Se

utiliza para devolver el logaritmo de un número especificado.
La Sintaxis del Método Math.Log es la siguiente:
public static double Log(double val);
 Ejemplo:
// of Math.Log(Double) method
using System;
class Geeks {
// Main Method
32
// double values whose logarithm
// to be calculated
double a = 4.55;
double b = 0;
double c = -2.45;
double positiveInfinity = Double.PositiveInfinity;
double negativeInfinity = Double.NegativeInfinity;
// Input is positive number so output
// will be logarithm of number
Console.WriteLine(Math.Log(a));
// positive zero as argument, so output
// will be -Infinity
Console.WriteLine(Math.Log(b));
// Input is negative number so output
// will be NaN
Console.WriteLine(Math.Log(c));
// Input is NaN so output
// will be NaN
Console.WriteLine(Math.Log(nan));
33
// Input is PositiveInfinity so output
// will be Infinity
Console.WriteLine(Math.Log(positiveInfinity));
// Input is NegativeInfinity so output
// will be NaN
Console.WriteLine(Math.Log(negativeInfinity));
 Método Math.Log10: Devuelve el logaritmo en base 10 de un número

especificado.
La Sintaxis del Método Math.Log10 es la siguiente:
public static double Log10(double val);
 Ejemplo:
// of Math.Log10(Double) method
using System;
class Geeks {
// Main Method
34
// double values whose logarithm
// to be calculated
double a = 4.55;
double b = 0;
double c = -2.45;
double positiveInfinity = Double.PositiveInfinity;
double negativeInfinity = Double.NegativeInfinity;
// Input is positive number so output
// will be logarithm of number
Console.WriteLine(Math.Log10(a));
// positive zero as argument, so output
// will be -Infinity
Console.WriteLine(Math.Log10(b));
// Input is negative number so output
// will be NaN
Console.WriteLine(Math.Log10(c));
// Input is NaN so output
// will be NaN
Console.WriteLine(Math.Log10(nan));
35
// Input is PositiveInfinity so output
// will be Infinity
Console.WriteLine(Math.Log10(positiveInfinity));
// Input is NegativeInfinity so output
// will be NaN
Console.WriteLine(Math.Log10(negativeInfinity));
 Método Math.Log2: Devuelve el logaritmo en base 2 de un número

especificado.
La Sintaxis del Método Math.Log2 es la siguiente:
public static double Log2 (double arg);
 Ejemplo:
using System;
class MyProgram {
Console.WriteLine("Math.Log2(0) = "
+ Math.Log2(0));
+ Math.Log2(10));
+ Math.Log2(50));
36
Console.WriteLine("Math.Log2(Double.NaN) = "
+ Math.Log2(Double.NaN));
Console.WriteLine("Math.Log2(Double.NegativeInfinity) = "
+ Math.Log2(Double.NegativeInfinity));
Console.WriteLine("Math.Log2(Double.PositiveInfinity) = "
+ Math.Log2(Double.PositiveInfinity));
 Método Math.Max: Devuelve el mayor de dos números especificados.
La Sintaxis del Método Math.Max es la siguiente:
public static data_type Max(Data_type first_value, Data_type second_value);
 Ejemplo:
// Math.Max() method
using System;
class GFG {
// Main Method
static void Main()
// byte data type
byte b1 = 10, b2 = 15;
37
// decimal data type
decimal d1 = 1000M, d2 = 1568M;
// double data type
double db1 = 15.896745, db2 = 8.62644598;
// Int16 data type
short sh1 = -96, sh2 = 24;
// Int32 data type
int i1 = 26745236, i2 = 36725413;
// Int64 data type
long l1 = -2534234234234, l2 = -745837587527423;
// sbyte data type
sbyte sb1 = 52, sb2 = 120;
// single data type
float f1 = 8.0f, f2 = 78.78f;
// UInt16 data type
ushort us1 = 5346, us2 = 6437;

38
// UInt32 data type
uint un1 = 432344637, un2 = 64762738;
// UInt64 data type
ulong ul1 = 34234234, ul2 = 673286478326;
// displaying result
Console.WriteLine("Math.Max Method (Byte, Byte) = " + Math.Max(b1,

b2));
Console.WriteLine("Math.Max Method (Decimal, Decimal) = " +

Math.Max(d1, d2));
Console.WriteLine("Math.Max Method (Double, Double) = " +

Math.Max(db1, db2));
Console.WriteLine("Math.Max Method (Int16, Int16) = " + Math.Max(sh1,

sh2));
Console.WriteLine("Math.Max Method (Int32, Int32) = " + Math.Max(i1,

i2));
Console.WriteLine("Math.Max Method (Int64, lInt64) = " + Math.Max(l1,

l2));
Console.WriteLine("Math.Max Method (SByte, SByte) = " +

Math.Max(sb1, sb2));
Console.WriteLine("Math.Max Method (Single, Single) = " + Math.Max(f1,

f2));
Console.WriteLine("Math.Max Method (UInt16, UInt16) = " +

Math.Max(us1, us2));
39
Math.Max(un1, un2));

Math.Max(ul1, ul2));
 Método Math.MaxMagnitude: Devuelve la magnitud mayor de dos

números de punto flotante de precisión doble.
La Sintaxis del Método Math.MaxMagnitude es la siguiente:
public static double MaxMagnitude (double value1, double value2);
 Ejemplo:
using System;
class Educative
static void Main()
double result = Math.MaxMagnitude(20, 30);
System.Console.WriteLine("MaxMagnitude(20, 30) = "+ result);
double result1 = Math.MaxMagnitude(Double.NaN, 30);
System.Console.WriteLine("MaxMagnitude(NaN, 30) = "+ result1);
double result2 = Math.MaxMagnitude(20, -30);
System.Console.WriteLine("MaxMagnitude(20, -30) = "+ result2);
40
}
 Método Math.Min: Devuelve el menor de dos números.
La Sintaxis del Método Math.Min es la siguiente:
public static data_type Min(Data_type first_value, Data_type second_value);
 Ejemplo:
// Math.Min() method
using System;
class GFG {
// Main Method
static void Main()
// byte data type
byte b1 = 10, b2 = 15;
decimal d1 = 1000M, d2 = 1568M;
// double data type
double db1 = 15.896745, db2 = 8.62644598;
41
// Int16 data type
short sh1 = -96, sh2 = 24;
// Int32 data type
int i1 = 26745236, i2 = 36725413;
// Int64 data type
long l1 = -2534234234234, l2 = -745837587527423;
// sbyte data type
sbyte sb1 = 52, sb2 = 120;
// single data type
float f1 = 8.0f, f2 = 78.78f;
// UInt16 data type
ushort us1 = 5346, us2 = 6437;
// UInt32 data type
uint un1 = 432344637, un2 = 64762738;
// UInt64 data type

42
ulong ul1 = 34234234, ul2 = 673286478326;
Console.WriteLine("Math.Min Method (Byte, Byte) = " + Math.Min(b1,

b2));
Console.WriteLine("Math.Min Method (Decimal, Decimal) = " +

Math.Min(d1, d2));
Console.WriteLine("Math.Min Method (Double, Double) = " +

Math.Min(db1, db2));
Console.WriteLine("Math.Min Method (Int16, Int16) = " + Math.Min(sh1,

sh2));
Console.WriteLine("Math.Min Method (Int32, Int32) = " + Math.Min(i1,

i2));
Console.WriteLine("Math.Min Method (Int64, lInt64) = " + Math.Min(l1,

l2));
Console.WriteLine("Math.Min Method (SByte, SByte) = " + Math.Min(sb1,

sb2));
Console.WriteLine("Math.Min Method (Single, Single) = " + Math.Min(f1,

f2));
Console.WriteLine("Math.Min Method (UInt16, UInt16) = " +

Math.Min(us1, us2));

Math.Min(un1, un2));

Math.Min(ul1, ul2));
}
43
}
 Método Math.MinMagnitude: Devuelve la magnitud menor de dos

números de punto flotante de precisión doble.
La Sintaxis del Método Math.MinMagnitude es la siguiente:
public static double MinMagnitude (double x, double y);
 Ejemplo:
// Math.Min() method
using System;
class GFG {
// Main Method
static void Main()
// byte data type
byte b1 = 10, b2 = 15;
decimal d1 = 1000M, d2 = 1568M;
// double data type
double db1 = 15.896745, db2 = 8.62644598;
44
// Int16 data type
short sh1 = -96, sh2 = 24;
// Int32 data type
int i1 = 26745236, i2 = 36725413;
// Int64 data type
long l1 = -2534234234234, l2 = -745837587527423;
// sbyte data type
sbyte sb1 = 52, sb2 = 120;
// single data type
float f1 = 8.0f, f2 = 78.78f;
// UInt16 data type
ushort us1 = 5346, us2 = 6437;
// UInt32 data type
uint un1 = 432344637, un2 = 64762738;
// UInt64 data type
ulong ul1 = 34234234, ul2 = 673286478326;
45
Console.WriteLine("Math.Min Method (Byte, Byte) = " + Math.Min(b1,

b2));
Console.WriteLine("Math.Min Method (Decimal, Decimal) = " +

Math.Min(d1, d2));
Console.WriteLine("Math.Min Method (Double, Double) = " +

Math.Min(db1, db2));
Console.WriteLine("Math.Min Method (Int16, Int16) = " + Math.Min(sh1,

sh2));
Console.WriteLine("Math.Min Method (Int32, Int32) = " + Math.Min(i1,

i2));
Console.WriteLine("Math.Min Method (Int64, lInt64) = " + Math.Min(l1,

l2));
Console.WriteLine("Math.Min Method (SByte, SByte) = " + Math.Min(sb1,

sb2));
Console.WriteLine("Math.Min Method (Single, Single) = " + Math.Min(f1,

f2));

Math.Min(us1, us2));

Math.Min(un1, un2));

Math.Min(ul1, ul2));
46
 Método Math.Pow: Devuelve un número especificado elevado a la
potencia especificada.
La Sintaxis del Método Math.Pow es la siguiente:
public static double Pow(double base, double power);
 Ejemplo:
// Math.Pow() function
using System;
class GFG {
// Main Method
static public void Main()
// Find power using Math.Pow
// 6 is base and 2 is power or
// index or exponent of a number
double pow_ab = Math.Pow(6, 2);
// Print the result
Console.WriteLine(pow_ab);
// 3.5 is base and 3 is power or
double pow_tt = Math.Pow(3.5, 3);
47
// Print the result
Console.WriteLine(pow_tt);
// 202 is base and 4 is power or
double pow_t = Math.Pow(202, 4);
// Print the result
Console.WriteLine(pow_t);
 Método Math.ReciprocalEstimate: Devuelve una estimación de la

recíproca de un número especificado.
La Sintaxis del Método Math.ReciprocalEstimate es la siguiente:
public static double ReciprocalEstimate (double d);
 Ejemplo:
(double sin, double cos) = Math.SinCos(1.57);
Console.WriteLine($"Sin = {sin}\nCos = {cos}");
// Computes an approximate of 1 / x
double recEst = Math.ReciprocalEstimate(5);
Console.WriteLine($"Reciprocal estimate = {recEst}");
// Computes an approximate of 1 / Sqrt(x)
double recSqrtEst = Math.ReciprocalSqrtEstimate(5);
Console.WriteLine($"Reciprocal sqrt estimate = {recSqrtEst}");
48
// New overloads
// Min, Max, Abs, Clamp and Sign supports nint and nuint
(nint a, nint b) = (5, 10);
nint min = Math.Min(a, b);
nint max = Math.Max(a, b);
nint abs = Math.Abs(a);
nint clamp = Math.Clamp(abs, min, max);
nint sign = Math.Sign(a);
Console.WriteLine($"Min = {min}\nMax = {max}\nAbs = {abs}");
Console.WriteLine($"Clamp = {clamp}\nSign = {sign}");
// DivRem variants return a tuple
(int quotient, int remainder) = Math.DivRem(2, 7);
Console.WriteLine($"Quotient = {quotient}\nRemainder = {remainder}");
 Método Math.ReciprocalSqrtEstimate: Devuelve una estimación de la

raíz cuadrada recíproca de un número especificado.
La Sintaxis del Método Math.ReciprocalSqrtEstimate es la siguiente:
public static double ReciprocalSqrtEstimate (double d);
 Ejemplo
// New methods SinCos, ReciprocalEstimate and ReciprocalSqrtEstimate
// Simultaneously computes Sin and Cos
(double sin, double cos) = Math.SinCos(1.57);
Console.WriteLine($"Sin = {sin}\nCos = {cos}");
// Computes an approximate of 1 / x
49
double recEst = Math.ReciprocalEstimate(5);
Console.WriteLine($"Reciprocal estimate = {recEst}");
// Computes an approximate of 1 / Sqrt(x)
double recSqrtEst = Math.ReciprocalSqrtEstimate(5);
Console.WriteLine($"Reciprocal sqrt estimate = {recSqrtEst}");
// New overloads
// Min, Max, Abs, Clamp and Sign supports nint and nuint
(nint a, nint b) = (5, 10);
nint min = Math.Min(a, b);
nint max = Math.Max(a, b);
nint abs = Math.Abs(a);
nint clamp = Math.Clamp(abs, min, max);
nint sign = Math.Sign(a);
Console.WriteLine($"Min = {min}\nMax = {max}\nAbs = {abs}");
Console.WriteLine($"Clamp = {clamp}\nSign = {sign}");
// DivRem variants return a tuple
(int quotient, int remainder) = Math.DivRem(2, 7);
Console.WriteLine($"Quotient = {quotient}\nRemainder = {remainder}");
// Output:
// Sin = 0.9999996829318346
50
// Cos = 0.0007963267107331026
// Reciprocal estimate = 0.2
// Reciprocal sqrt estimate = 0.4472135954999579
// Min = 5
// Max = 10
// Abs = 5
// Clamp = 5
// Sign = 1
// Quotient = 0
// Remainder = 2
 Método Math.Round: Redondea un valor al entero más próximo o al

número especificado de dígitos fraccionarios.
La Sintaxis del Método Math.Round es la siguiente:
public static double Round(double x)
 Ejemplo:
// Math.Round(Double) method
using System;
class Geeks {
// Main method
51
// Case-1
// A double value whose fractional part is
// less than the halfway between two
// consecutive integers
Double dx1 = 12.434565d;
// Output value will be 12
Console.WriteLine("Rounded value of " + dx1 +
" is " + Math.Round(dx1));
// Case-2
// A double value whose fractional part is
// greater than the halfway between two
// consecutive integers
Double dx2 = 12.634565d;
// Output value will be 13
Console.WriteLine("Rounded value of " + dx2 +
" is " + Math.Round(dx2));
 Método Math.ScaleB: Devuelve x * 2^n calculado de forma eficaz.
La Sintaxis del Método Math.ScaleB es la siguiente:
public static double ScaleB (double a, int b);
52
 Ejemplo:
using System;
class MyProgram {
Console.WriteLine("Math.ScaleB(2.55, 4) = "
+ Math.ScaleB(2.55, 4));
Console.WriteLine("Math.ScaleB(10, 3) = "
+ Math.ScaleB(10, 3));
Console.WriteLine("Math.ScaleB(Double.NaN, 3) = "
+ Math.ScaleB(Double.NaN, 3));
Console.WriteLine("Math.ScaleB(Double.PositiveInfinity, 3) = "
+ Math.ScaleB(Double.PositiveInfinity, 3));
 Método Math.Sign: Devuelve un entero que indica el signo de un

número.
La Sintaxis del Método Math.Sign es la siguiente:
public static int Sign(data_type value);
 Ejemplo:
// Math.Sign() method
using System;
class GFG {
53
// Main Method
// Decimal data type
Decimal de = 150M;
// Double data type
Double d = 34.5432d;
// Int16 data type
short sh = 0;
// Int32 data type
int i = -5678;
// Int64 data type
long l = 598964564;
// SByte data type
sbyte sb = -34;
// float data type
float f = 56.89f;
54
Console.WriteLine("Decimal: " + de + " " + check(Math.Sign(de)));
Console.WriteLine("Double: " + d + " " + check(Math.Sign(d)));
Console.WriteLine("Int16: " + sh + " " + check(Math.Sign(sh)));
Console.WriteLine("Int32: " + i + " " + check(Math.Sign(i)));
Console.WriteLine("Int64: " + l + " " + check(Math.Sign(l)));
Console.WriteLine("SByte: " + sb + " " + check(Math.Sign(sb)));
Console.WriteLine("Single: " + f + " " + check(Math.Sign(f)));
// function to check whether the input
// number is greater than zero or not
public static String check(int compare)
if (compare == 0)
return "equal to zero";
else if (compare < 0)
return "less than zero";
else
55
return "greater than zero";
 Método Math.Sin: Devuelve el seno del ángulo especificado.
La Sintaxis del Método Math.Sin es la siguiente:
public static double Sin(double num)
 Ejemplo:
// Math.Sin() method
using System;
class Geeks {
// Main Method
double a = 30;
Console.WriteLine(Math.Sin(b));
a = 45;
56
b = (a * (Math.PI)) / 180;
a = 60;
b = (a * (Math.PI)) / 180;
a = 90;
b = (a * (Math.PI)) / 180;
 Método Math.SinCos: Devuelve el seno y el coseno del ángulo

especificado.
La Sintaxis del Método Math.SinCos es la siguiente:
57
public static (double Sin, double Cos) SinCos (double x);
 Ejemplo:
// Example for the trigonometric Math.Sin( double )
// and Math.Cos( double ) methods.
using System;/* ww w .d em o 2 s . c o m */
class SinCos
Console.WriteLine(
"This example of trigonometric " +
"Math.Sin( double ), Math.Cos( double ), and Math.SinCos( double )\n" +
"generates the following output.\n" );
Console.WriteLine(
"Convert selected values for X to radians \n" +
"and evaluate these trigonometric identities:" );
Console.WriteLine( " sin^2(X) + cos^2(X) == 1\n" +
" sin(2 * X) == 2 * sin(X) * cos(X)" );
Console.WriteLine( " cos(2 * X) == cos^2(X) - sin^2(X)" );
Console.WriteLine( " cos(2 * X) == cos^2(X) - sin^2(X)" );
UseSineCosine(15.0);
Console.WriteLine(
58
"\nConvert selected values for X and Y to radians \n" +
"and evaluate these trigonometric identities:" );
Console.WriteLine( " sin(X + Y) == sin(X) * cos(Y) + cos(X) * sin(Y)" );
Console.WriteLine( " cos(X + Y) == cos(X) * cos(Y) - sin(X) * sin(Y)" );
UseTwoAngles(15.0, 30.0);
UseTwoAngles(30.0, 45.0);
Console.WriteLine(
"\nWhen you have calls to sin(X) and cos(X) they \n" +
"can be replaced with a single call to sincos(x):" );
UseCombinedSineCosine(15.0);
// Evaluate trigonometric identities with a given angle.
static void UseCombinedSineCosine(double degrees)
double angle = Math.PI * degrees / 180.0;
(double sinAngle, double cosAngle) = Math.SinCos(angle);
// Evaluate sin^2(X) + cos^2(X) == 1.
Console.WriteLine(
"\n Math.SinCos({0} deg) == ({1:E16}, {2:E16})",
degrees, sinAngle, cosAngle);
Console.WriteLine(
"(double sin, double cos) = Math.SinCos({0} deg)",
59
degrees );
Console.WriteLine(
"sin^2 + cos^2 == {0:E16}",
sinAngle * sinAngle + cosAngle * cosAngle );
// Evaluate trigonometric identities with a given angle.
static void UseSineCosine(double degrees)
double angle = Math.PI * degrees / 180.0;
double sinAngle = Math.Sin(angle);
double cosAngle = Math.Cos(angle);
// Evaluate sin^2(X) + cos^2(X) == 1.
Console.WriteLine(
"\n Math.Sin({0} deg) == {1:E16}\n" +
" Math.Cos({0} deg) == {2:E16}",
degrees, Math.Sin(angle), Math.Cos(angle) );
Console.WriteLine(
"(Math.Sin({0} deg))^2 + (Math.Cos({0} deg))^2 == {1:E16}",
degrees, sinAngle * sinAngle + cosAngle * cosAngle );
// Evaluate sin(2 * X) == 2 * sin(X) * cos(X).
Console.WriteLine(
" Math.Sin({0} deg) == {1:E16}",
2.0 * degrees, Math.Sin(2.0 * angle) );
Console.WriteLine(
60
" 2 * Math.Sin({0} deg) * Math.Cos({0} deg) == {1:E16}",
degrees, 2.0 * sinAngle * cosAngle );
// Evaluate cos(2 * X) == cos^2(X) - sin^2(X).
Console.WriteLine(
" Math.Cos({0} deg) == {1:E16}",
2.0 * degrees, Math.Cos(2.0 * angle) );
Console.WriteLine(
"(Math.Cos({0} deg))^2 - (Math.Sin({0} deg))^2 == {1:E16}",
degrees, cosAngle * cosAngle - sinAngle * sinAngle );
// Evaluate trigonometric identities that are functions of two angles.
static void UseTwoAngles(double degreesX, double degreesY)
double angleX = Math.PI * degreesX / 180.0;
double angleY = Math.PI * degreesY / 180.0;
// Evaluate sin(X + Y) == sin(X) * cos(Y) + cos(X) * sin(Y).
Console.WriteLine(
"\n Math.Sin({0} deg) * Math.Cos({1} deg) +\n" +
" Math.Cos({0} deg) * Math.Sin({1} deg) == {2:E16}",
degreesX, degreesY, Math.Sin(angleX) * Math.Cos(angleY) +
Math.Cos(angleX) * Math.Sin(angleY));
Console.WriteLine(
" Math.Sin({0} deg) == {1:E16}",
degreesX + degreesY, Math.Sin(angleX + angleY));
61
// Evaluate cos(X + Y) == cos(X) * cos(Y) - sin(X) * sin(Y).
Console.WriteLine(
" Math.Cos({0} deg) * Math.Cos({1} deg) -\n" +
" Math.Sin({0} deg) * Math.Sin({1} deg) == {2:E16}",
degreesX, degreesY, Math.Cos(angleX) * Math.Cos(angleY) -
Math.Sin(angleX) * Math.Sin(angleY));
Console.WriteLine(
" Math.Cos({0} deg) == {1:E16}",
degreesX + degreesY, Math.Cos(angleX + angleY));
 Método Math.Sinh: Devuelve el seno hiperbólico del ángulo

especificado.
La Sintaxis del Método Math.Sinh es la siguiente:
public static double Sinh(double num);
 Ejemplo:
// Math.Sinh()
using System;
class GFG {
// Main Method
62
double num1 = 78.8, num2 = 0.0, num3 = 1.0;
// It returns the hyperbolic sine of specified
// angle in radian
double sinhvalue = Math.Sinh(num1);
Console.WriteLine("The sinh of num1 = " + sinhvalue);
sinhvalue = Math.Sinh(num2);
sinhvalue = Math.Sinh(num3);
 Método Math.Sqrt: Devuelve la raíz cuadrada de un número

especificado.
La Sintaxis del Método Math.Sqrt es la siguiente:
public static double Sqrt (double value);
 Ejemplo:
using System;
class Educative
static void Main()
63
Double result = Math.Sqrt(-0.16);
System.Console.WriteLine("Sqrt(0.16) = "+ result);
Double result1 = Math.Sqrt(0);
System.Console.WriteLine("Sqrt(0) = "+ result1);
Double result2 = Math.Sqrt(16);
System.Console.WriteLine("Sqrt(16) = "+ result2);
Double result3 = Math.Sqrt(Double.PositiveInfinity);
System.Console.WriteLine("Sqrt(∞) = "+ result3);
Double result4 = Math.Sqrt(Double.NegativeInfinity);
System.Console.WriteLine("Sqrt(-∞) = "+ result4);
 Método Math.Tan: Devuelve la tangente del ángulo especificado.
La Sintaxis del Método Math.Tan es la siguiente:
public static double Tan(double num);
 Ejemplo:
// Math.Tan() method
using System;
64
class Geeks {
// Main Method
double a = 12;
Console.WriteLine(Math.Tan(b));
a = 63;
b = (a * (Math.PI)) / 180;
a = 187;
b = (a * (Math.PI)) / 180;
65
a = 45;
b = (a * (Math.PI)) / 180;
 Método Math.Tanh: El método Math.Tanh() en C# se usa para devolver

la tangente hiperbólica del ángulo especificado.
La Sintaxis del Método Math.Tanh es la siguiente:
Math.Tanh(Double value);
 Ejemplo:
using System;
class Example {
Double value, result;
value = 1; //1 radian
result = Math.Tanh(value);
Console.WriteLine($"Tanh({value} radian) = {result}.");
66
value = Math.PI; // PI radians or 180 degrees
value = Math.PI/2; // 90 degrees
value = 0; // 0 degrees
value = Double.PositiveInfinity;
value = Double.NegativeInfinity;
 Math.Truncate: Calcula la parte entera de un número.
La Sintaxis del Método Math.Truncate es la siguiente:
public static decimal Truncate(decimal dec);

67
 Ejemplo:
// Math.Truncate(Decimal) Method
using System;
class Geeks {
// Main Method
// variables of Decimal type
Decimal dec = 45.89511m;
Decimal dec2 = 54569.478021m;
// using function and displaying result
Console.WriteLine(Math.Truncate(dec));
Console.WriteLine(Math.Truncate(dec2));
68

Metodos Math

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Metodos Math

Cargado por

Copyright:

Formatos disponibles

Nombre del Estudiante: Orbin Daniel Morales López

Número de Cuenta: 1220207

Nombre del Catedrático/a: Lic. Eldrin Salomón Mejía Guzmán

Horario de Clase: 6:10 PM – 9:10 PM

Fecha de Elaboración: 14/09/2022

 Método Math.Abs: Devuelve el valor absoluto de un número

La Sintaxis del Método Math.Abs es la siguiente:

public static decimal Abs (decimal val);

// C# Program to illlustrate the

public static void Main()

// Taking decimal values

decimal[] deci = {Decimal.MinValue, 45.14M, 0M,

// using foreach loop

foreach(decimal value in deci)

// Displaying the result

 Método Math.Acos: Devuelve el ángulo cuyo coseno es el número

La Sintaxis del Método Math.Acos es la siguiente:

public static double Acos(double num)

// C# program to demonstrate working

public static void Main(String[] args)

// using Math.Acos() method

// argument is greater than 1

double posi = Double.PositiveInfinity;

double nega = Double.NegativeInfinity;

double nan = Double.NaN;

// Input positive zero

double res = Math.Acos(d);

// i.e output will be 90 degree

double rest = res * (180 / Math.PI);

// Input negative zero

 Método Math.Acosh: Devuelve el ángulo cuyo coseno hiperbólico es el

La Sintaxis del Método Math.Acosh es la siguiente:

public static float Acosh (float x);

// C# program to demonstrate the

public static void Main()

// Declaring and initializing value

float value = 2.5f;

// getting hyperbolic arc-cosine value

// using Acosh() method

float result = MathF.Acosh(value);

// Display the value

Console.WriteLine("Angle is {0}", result);

 Método Math.Asin: Devuelve el ángulo cuyo seno es el número

La Sintaxis del Método Math.Asin es la siguiente:

public static double Asin(double num)

// C# program to demonstrate working

// using Math.Asin() method

// argument is greater than 1

double posi = Double.PositiveInfinity;

double nega = Double.NegativeInfinity;

double nan = Double.NaN;

// Input positive zero

double res = Math.Asin(d);

// i.e. output is 0 degree

// Input negative zero

 Método Math.Asinh: El método Math.Asinh se utiliza para devolver el

La Sintaxis del Método Math.Asinh es la siguiente:

public static void Main()

// Declaring and initializing value

float value = 1.5f;

// getting hyperbolic arc-cosine value

// using Asinh() method