.NET -
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(x) | Fornece Valor absoluto de x | Abs(4.5) = 4.5; Abs(-4.5) = 4.5; |
| Ceiling(x) | Arredonda x para cima |
Ceiling(4.1) = 5; 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(x) | Arredonda o valor de x para baixo | Floor(2.9) = 2; 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(x,y) | Obtém o maior valor entre dois números | Max(2.46,2.56) = 2.56; Max(-2.46,-2.56) = 2.46; |
| Min(x,y) | Obtém o menor valor entre dois números | Min(1.92,1.89) = 1.89; 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; namespace CalcularAreaCirculo{ class Program { static void Main(string[] args) { double areaCirculo = 0; double RaioDoCirculo = 0; Console.WriteLine(" Informe o raio do Círculo : "); RaioDoCirculo = Convert.ToDouble(Console.ReadLine()); areaCirculo = Math.PI * Math.Pow(RaioDoCirculo, 2); Console.WriteLine(" A área do círculo de raio " + RaioDoCirculo.ToString() + " é : " + areaCirculo.ToString()); Console.ReadKey(); } } } |
Module
Module1
Sub
Main() Console.ReadKey() End
Sub
|
| C# | VB .NET |
O resultado pode ser visto abaixo:
 |
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))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.
|
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.46, 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.56, 1)) ' retorna 5.6 Console.ReadKey() |
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.46, 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.56, 1)); // retorna 5.6 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 :
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;
 |
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));
}
/// <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:
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;
 |
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:
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.
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);
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:
José Carlos Macoratti