22/06/2019 C# - A classe Math

.NET - A classe Math

A classe System.Math oferece muitos campos constantes e métodos estáticos que você pode usar para fazer cálculos trigonométricos,
logarítmicos, e outros cálculos matemáticos. Por exemplo, o método Pow da classe System.Math pode ser usado para elevar um número a uma
potência de x.

A seguir alguns exemplos de funções matemáticas e constantes existentes na classe System.Math:

Função/Constantes Resultado Exemplo

Abs(4.5) = 4.5;
Abs(x) Fornece Valor absoluto de x
Abs(-4.5) = 4.5;

Ceiling(4.1) = 5;
Ceiling(x) Arredonda x para cima
Ceiling(-4.1) = -4;

Cos(x) Obtém o cosseno de x Cos(2.0) = -0.4161......

Sin(x) Obtém o seno de x Sin(2) = 0.909297...

Tan(x) Obtém o valor da Tangente de x Tan(1.5) =14.1014...

PI Obtém o valor de PI PI = 3.141516171819...

E Obtém o valor da constante E E = 2.7182818284590451

Exp(x) Obtém o exponencial (e elevado na x) Exp(5.0) =54.59...

Floor(2.9) = 2;
Floor(x) Arredonda o valor de x para baixo
Floor(-2.9)) = -3;

Log(x) Calcula o logaritmo de x na base natural e Log(3.0) = 1.098612...

Log10(x) Calcula o logaritmo de x na base 10 Log10(3.0) = 0.47712...

Max(2.46,2.56) = 2.56;
Max(x,y) Obtém o maior valor entre dois números
Max(-2.46,-2.56) = 2.46;

Min(1.92,1.89) = 1.89;
Min(x,y) Obtém o menor valor entre dois números
Min(-1.92,-1.89) = 1.92;

Pow(x,y) Obtém o valor de x elevado na y Pow(2,4) = 16

Round(x,y) Arredonda x para y casas decimais Round(7.6758549,4) = 7.6759

Sqrt(x) Obtém a raiz quadrada de x Sqrt(169) = 13

Vamos usar o método Pow e o campo Math.PI (devolve o valor de PI, a razão entre a circunferência de um círculo com o seu diâmetro), para
calcular a área de um círculo . Onde RaioDoCirculo é o raio de um círculo, e PI  é o número 3.14159265358979323846.

Crie um novo projeto usando o Visual Studio Express 2012 for Desktop. Escolha a sua linguagem de preferência VB .NET ou C#. Informe o nome do
projeto como AreaDoCirculo;

A seguir defina o seguinte código em arquivo Program.cs para projeto C# ou no modulo padrão em Sub Main() para um projeto VB .NET:

using System;
Module Module1
namespace CalcularAreaCirculo
{ Sub Main()
 class Program
 { Dim areaCirculo As Double
  static void Main(string[] args) Dim RaioDoCirculo As Double
 {
Console.WriteLine(" Informe o raio do Círculo : ")
   double areaCirculo = 0; RaioDoCirculo = Convert.ToDouble(Console.ReadLine)
   double RaioDoCirculo = 0; areaCirculo = Math.PI * Math.Pow(RaioDoCirculo, 2)
   Console.WriteLine(" Informe o raio do Círculo : "); Console.WriteLine(" A área do círculo de raio " &
   RaioDoCirculo = Convert.ToDouble(Console.ReadLine()); RaioDoCirculo.ToString & " é : " & areaCirculo.ToString)
   areaCirculo = Math.PI * Math.Pow(RaioDoCirculo, 2);
   Console.WriteLine(" A área do círculo de raio " +  Console.ReadKey()
RaioDoCirculo.ToString() + " é : " + areaCirculo.ToString());
End Sub
   Console.ReadKey();
End Module
 }
 }
}
C# VB .NET

O resultado pode ser visto abaixo:

www.macoratti.net/13/03/c_mat1.htm 1/7
22/06/2019 C# - A classe Math

Outra constante, diferente de PI, é a base logarítmica natural ou constante de Euler, especificada pela constante Math.E (
2,7182818284590452354). O método Log() calcula o logaritmo de um número especificado em uma base especificada.

Assim o método Log(double a,double novaBase) tem dois parâmetros. O primeiro é o número cujo logaritmo é para ser encontrado, e o segundo é
a base do logaritmo.

Então podemos fazer:

Console.WriteLine(System.Math.Log(Math.E, 10))
Console.ReadKey()

A função Math.Round tem outra sobrecarga com o qual você pode especificar o número de dígitos além do ponto decimal no valor retornado.

Em outras palavras, ele retorna o valor mais próximo do número com precisão igual ao segundo parâmetro passado.

Se o valor para arredondar esta exatamente a meio caminho entre um par e um número ímpar (por exemplo, 0,45, com precisão de 1),
então o número ainda é retornado.
Se o número de dígitos após o decimal no primeiro parâmetro é menor do que o número de precisão no segundo parâmetro, então o método
Round retorna ao valor passado. Veja alguns exemplos abaixo:

Console.WriteLine(Math.Round(5.44, 1)) ' retorna 5.4 Console.WriteLine(Math.Round(5.44, 1)); // retorna 5.4

Console.WriteLine(Math.Round(5.45, 1)) ' retorna 5.4 Console.WriteLine(Math.Round(5.45, 1)); // retorna 5.4
Console.WriteLine(Math.Round(5.46, 1)) ' retorna 5.5 Console.WriteLine(Math.Round(5.46, 1)); // retorna 5.5
Console.WriteLine(Math.Round(5.54, 1)) ' retorna 5.5 Console.WriteLine(Math.Round(5.54, 1)); // retorna 5.5
Console.WriteLine(Math.Round(5.55, 1)) ' retorna 5.6 Console.WriteLine(Math.Round(5.55, 1)); // retorna 5.6
Console.WriteLine(Math.Round(5.56, 1)) ' retorna 5.6 Console.WriteLine(Math.Round(5.56, 1)); // retorna 5.6
Console.ReadKey() Console.ReadKey();
VB .NET  C#

Você pode usar o método Floor para truncar um número real. O método retorna o maior número inteiro menor que o número original. Por
exemplo, use o seguinte para obter o Floor de 4.8.

            Console.WriteLine(Math.floor (4.8));  //retorna 4

            Console.WriteLine(Math.floor (-4.8)); //retorna -5

A resposta seria 4. Observe que o método Floor pode se comportar diferentemente do que você poderia esperar para valores negativos. Por
exemplo, Math.floor (-4.8) retorna -5.

O método de Celing faz o contrário, retornando o menor número inteiro maior do que o original.

             Console.WriteLine(Math.Ceiling (4.8));  //retorna 5

             Console.WriteLine(Math.Ceiling (-4.8));  //retorna -4

Criando uma classe para cálculo de área de volume com base na classe Math

Vamos agora criar uma classe para realizar alguns cálculos de área e volume com base na classe Math.

Esta classe será uma classe estática com métodos estáticos de forma que não precisaremos instanciar a classe para acessar os seus métodos.

Para criar a classe estática vamos estar atentos às seguintes regras :

Regra#1.  Uma classe estática deve conter a palavra chave static na declaração da classe;
Regar#2.  Para definir um método  estático devemos usar a palavra chave static na definição método;
Regra#3.  Em uma classe estática o construtor deve ser estático pois a classe não pode ser instanciada;
Regra#4.  O construtor não deve conter um modificador de acesso;
Regar#5.  Uma classe estática não pode implementar uma interface;

Iremos criar um projeto do tipo Class Library de forma que o afinal teremos uma DLL que poderemos referenciar em qualquer tipo de projeto.

Abra o Visual Studio Express 2012 for desktop e clique no menu File-> New Project;

A seguir selecione o template : Visual C# -> Class Library, informando o nome MacMath;

www.macoratti.net/13/03/c_mat1.htm 2/7
22/06/2019 C# - A classe Math

A seguir defina o seguinte código nesta classe:       

using System;

namespace Macoratti
{
public static class MacMath
{
/// <summary>
/// Area do Quadrado em função do lado
/// </summary>
/// <param name="lado"></param>
/// <returns></returns>
public static double AreaQuadrado(double lado)
{
return lado * lado;
}
/// <summary>
/// Area do quadrado com base na diagonal
/// </summary>
/// <param name="diagonal"></param>
/// <returns></returns>
public static double AreaQuadradoDiagonal(double diagonal)
{
return (diagonal * diagonal) / 2;
}
/// <summary>
/// Area do tringulo em função da base e altura
/// </summary>
/// <param name="altura"></param>
/// <param name="valorBase"></param>
/// <returns></returns>
public static double AreaTriangulo(double altura, double valorBase)
{
return (valorBase * altura)/2;
}
/// <summary>
/// Area do retangulo em função da base e altura
/// </summary>
/// <param name="valorBase"></param>
/// <param name="altura"></param>
/// <returns></returns>
public static double AreaRetangulo(double valorBase, double altura)
{
return (valorBase * altura);
}
/// <summary>
/// Area do circulo em função do raio
/// Usa a constante PI
/// </summary>
/// <param name="raio"></param>
/// <returns></returns>
public static double AreaCirculo(double raio)
{
return (raio * Math.PI);
}
/// <summary>
/// Area do trapezio em função da altura e base menor e maior
/// </summary>
/// <param name="altura"></param>
/// <param name="baseMenor"></param>
/// <param name="baseMaior"></param>
/// <returns></returns>
public static double AreaTrapezio(double altura, double baseMenor, double baseMaior)
{
return (altura * (baseMaior - baseMenor)) / 2;
}
/// <summary>
/// Area d Anel(setor circular em função dos raios interno e externo
/// </summary>
/// <param name="raioInterno"></param>
/// <param name="raioExterno"></param>
/// <returns></returns>
public static double AreaSetorCircular(double raioInterno,double raioExterno)
{
return (AreaCirculo(raioInterno) - AreaCirculo(raioExterno));

www.macoratti.net/13/03/c_mat1.htm 3/7
22/06/2019 C# - A classe Math
}
/// <summary>
/// Volume do cilindro com base na altura e raio
/// </summary>
/// <param name="altura"></param>
/// <param name="raio"></param>
/// <returns></returns>
public static double VolumeCilindro(double altura, double raio)
{
return Math.PI * Math.Pow(raio,2) * altura;
}
/// <summary>
/// Volume de um tubo (cilindro vasado)
/// </summary>
/// <param name="altura"></param>
/// <param name="raioExterno"></param>
/// <param name="raioInterno"></param>
/// <returns></returns>
public static double VolumeCilindroOco(double altura, double raioExterno, double raioInterno)
{
return VolumeCilindro(altura, raioExterno) - VolumeCilindro(altura, raioInterno);
}
/// <summary>
/// Volume da Esfora com base no raio
/// </summary>
/// <param name="raio"></param>
/// <returns></returns>
public static double VolumeEsfera(double raio)
{
return 4 / 3 * Math.PI * Math.Pow(raio, 3);
}
/// <summary>
/// Area da esfera com base no raio
/// </summary>
/// <param name="raio"></param>
/// <returns></returns>
public static double AreaEsfera(double raio)
{
return 4 * Math.PI * Math.Pow(raio, 2);
}
/// <summary>
/// Volume da Piramide em função da altura e area da base
/// </summary>
/// <param name="altura"></param>
/// <param name="areaBase"></param>
/// <returns></returns>
public static double VolumePiramide(double altura, double areaBase)
{
return (altura * areaBase) / 3;
}
}
}

Estamos criando os seguintes métodos nesta classe:

AreaQuadrado -  lado * lado;

AreaQuadradoDiagonal - (diagonal * diagonal) / 2;
AreaTriangulo -  (valorBase * altura)/2;
AreaRetangulo - (valorBase * altura);
AreaCirculo - (raio * Math.PI);
AreaTrapezio - (altura * (baseMaior - baseMenor)) / 2;
AreaSetorCircular - AreaCirculo(raioInterno) - AreaCirculo(raioExterno));
VolumeCilindro - Math.PI * Math.Pow(raio,2) * altura;
VolumeCilindroOco - VolumeCilindro(altura, raioExterno) - VolumeCilindro(altura, raioInterno);
VolumeEsfera - 4 / 3 * Math.PI * Math.Pow(raio, 3);
AreaEsfera - 4 * Math.PI * Math.Pow(raio, 2);
VolumePiramide - (altura * areaBase) / 3;

Cada método possui uma documentação básica e usa as fórmulas matemáticas para calcular a respectiva área e/ou volume.

Após criar a classe compile o projeto de forma gerar o arquivo dll - MacMath.dll - que iremos referenciar em um projeto Windows Forms de forma
a usar os métodos para calcular algumas áreas e volumes.

Criando o projeto Windows Forms e usando a classe MacMath

Abra o Visual Studio Express 2012 for desktop e clique no menu File-> New Project;

A seguir selecione o template : Visual C# ->Windows Forms, informando o nome Calculando;

www.macoratti.net/13/03/c_mat1.htm 4/7
22/06/2019 C# - A classe Math

Vamos agora incluir a referência a nossa dll criada no projeto Class Library.

No menu PROJECT clique em Add Reference e a seguir na guia Browse e localize onde você criou o arquivo dll do projeto Class Library:

Selecione o arquivo e clique no botão OK;

Agora vamos definir uma interface bem simples no formulário form1.cs usando os seguintes controles:

TabControl
Panel
Picture
TextBox
Button

Abaixo vemos o leiaute do formulário exibindo as duas visualizações possíveis:

Abaixo temos o código do formulário iniciando com a declaração dos namespaces. Note que estamos declarando o namespace Macoratti de forma
a simplificar a chamada dos métodos da Library.

www.macoratti.net/13/03/c_mat1.htm 5/7
22/06/2019 C# - A classe Math
O código do formulário abaixo mostra que no evento Click de cada botão de comando estamos chamando diretamente o método da classe
MacMath sem a necessidade de criar uma instância da classe pois ela é uma classe estática.

Exemplo da chamada do método AreaQuadrado da classe MacMath :  MacMath.AreaQuadrado(lado).ToString();

using System;
using System.Windows.Forms;
using Macoratti;

namespace Calculando
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void btnQuadrado_Click(object sender, EventArgs e)

{
if (String.IsNullOrEmpty(txtLado.Text))
{
MessageBox.Show("Informe o valor do lado do quadrado.", "Lado do Quadrado", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
//
try
{
double lado = Convert.ToDouble(txtLado.Text);
txtAreaQuadrado.Text = MacMath.AreaQuadrado(lado).ToString();
}
catch
{
MessageBox.Show("Ocorreu um erro no cálculo da área.", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
txtLado.Focus();
}
}
//valida o valor no textbox
private void txtLado_KeyPress(object sender, KeyPressEventArgs e)
{
e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar ==',');
}

private void btnRetangulo_Click(object sender, EventArgs e)

{
if (String.IsNullOrEmpty(txtBaseRetangulo.Text))
{
MessageBox.Show("Informe o valor da base do retângulo.", "Base do Retângulo", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
if (String.IsNullOrEmpty(txtAlturaRetangulo.Text))
{
MessageBox.Show("Informe o valor da altura do retângulo.", "Altura do Retângulo", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
//
try
{
double b = Convert.ToDouble(txtBaseRetangulo.Text);
double a = Convert.ToDouble(txtAlturaRetangulo.Text);
txtAreaRetangulo.Text = MacMath.AreaRetangulo(b,a).ToString();
}
catch
{
MessageBox.Show("Ocorreu um erro no cálculo da área.", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
txtLado.Focus();
}
}

private void txtBaseRetangulo_KeyPress(object sender, KeyPressEventArgs e)

{
e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar == ',');
}

private void txtAlturaRetangulo_KeyPress(object sender, KeyPressEventArgs e)

{
e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar == ',');
}

private void btnVolumeEsfera_Click(object sender, EventArgs e)

{
if (String.IsNullOrEmpty(txtRaioEsfera.Text))
{
MessageBox.Show("Informe o valor do raio da esfera.", "Raio da Esfera", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
//
try
{
double raio = Convert.ToDouble(txtRaioEsfera.Text);
txtVolumeEsfera.Text = MacMath.VolumeEsfera(raio).ToString();
}
catch
{
MessageBox.Show("Ocorreu um erro no cálculo da área.", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
txtRaioEsfera.Focus();
}
}

private void btnVolumeCilindro_Click(object sender, EventArgs e)

{
if (String.IsNullOrEmpty(txtAlturaCilindro.Text))
{
MessageBox.Show("Informe o valor da altura do Cilindro.", "Altura do Cilindro", MessageBoxButtons.OK, MessageBoxIcon.Information);

www.macoratti.net/13/03/c_mat1.htm 6/7
22/06/2019 C# - A classe Math
return;
}
if (String.IsNullOrEmpty(txtRaioCilindro.Text))
{
MessageBox.Show("Informe o valor do raio do Cilindro.", "Raio do Cilindro", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
//
try
{
double altura = Convert.ToDouble(txtRaioCilindro.Text);
double raio = Convert.ToDouble(txtAlturaCilindro.Text);
txtVolumeCilindro.Text = MacMath.VolumeCilindro(raio,altura).ToString();
}
catch
{
MessageBox.Show("Ocorreu um erro no cálculo da área.", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
lblaltura.Focus();
}
}

private void txtRaioEsfera_KeyPress(object sender, KeyPressEventArgs e)

{
e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar == ',');
}

private void txtRaioCilindro_KeyPress(object sender, KeyPressEventArgs e)

{
e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar == ',');
}

private void textBox5_KeyPress(object sender, KeyPressEventArgs e)

{
e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar == ',');
}
}
}

Estamos usando o evento KeyPress para permitir somente valores numéricos nas caixas de texto e estamos verificando se foram informando
valores nas caixas de texto.

O código básico é :  e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && !(e.KeyChar == ',');

que permite somente números, a vírgula e backspace.

Pegue o projeto completo aqui:  MacMath.zip e Calculando.zip

1Pe 2:6 Por isso, na Escritura se diz: Eis que ponho em Sião uma principal pedra angular, eleita e preciosa; e quem nela crer não será
confundido.

1Pe 2:7 E assim para vós, os que credes, é a preciosidade; mas para os descrentes, a pedra que os edificadores rejeitaram, esta foi
posta como a principal da esquina,

1Pe 2:8 e: Como uma pedra de tropeço e rocha de escândalo; porque tropeçam na palavra, sendo desobedientes; para o que também
foram destinados.

Referências:

Seção VB .NET do Site Macoratti.net

Super DVD .NET - A sua porta de entrada na plataforma .NET
Super DVD Vídeo Aulas - Vídeo Aula sobre VB .NET, ASP .NET e C#
Seção C# do site Macoratti.net
C# - Conceitos básicos - Classes Estáticas - Macoratti.net
Funções Matemáticas - Macoratti.net
.NET Framework : introdução é classes mais ... - Macoratti.net
C# - Avaliando Expressões Matemáticas - Macoratti.net

José Carlos Macoratti

www.macoratti.net/13/03/c_mat1.htm 7/7