 |
|
Você está aqui: Cards de Engenharia Civil - Estruturas de Aço e Madeira |
||
|
||
 Link para compartilhar na Internet ou com seus amigos: |
||
Delphi ::: Dicas & Truques ::: Matemática e Estatística |
Como calcular juros simples e montante usando DelphiQuantidade de visualizações: 13662 vezes |
|
O regime de juros será simples quando o percentual de juros incidir apenas sobre o valor principal. Sobre os juros gerados a cada período não incidirão novos juros. Valor Principal ou simplesmente principal é o valor inicial emprestado ou aplicado, antes de somarmos os juros. Transformando em fórmula temos: J = P . i . n Onde: J = juros P = principal (capital) i = taxa de juros n = número de períodos Imaginemos uma dívida de R$ 2.000,00 que deverá ser paga com juros de 5% a.m. pelo regime de juros simples e o prazo para o pagamento é de 2 meses. O cálculo em Delphi pode ser feito assim:
procedure TForm1.Button1Click(Sender: TObject);
var
principal, taxa, juros: double;
meses: integer;
begin
principal := 2000.00;
taxa := 0.08;
meses := 2;
juros := principal * taxa * meses;
ShowMessage('O total de juros a ser pago é: '
+ FloatToStr(juros));
end;
O montante da dívida pode ser obtido das seguintes formas: a) Montante = Principal + Juros b) Montante = Principal + (Principal x Taxa de juros x Número de períodos) M = P . (1 + (i . n)) Veja o código:
procedure TForm1.Button1Click(Sender: TObject);
var
principal, taxa, juros, montante: double;
meses: integer;
begin
principal := 2000.00;
taxa := 0.08;
meses := 2;
juros := principal * taxa * meses;
montante := principal * (1 + (taxa * meses));
ShowMessage('O total de juros a ser pago é: '
+ FloatToStr(juros));
ShowMessage('O montante a ser pago é: '
+ FloatToStr(montante));
end;
Para questões de compatibilidade, esta dica foi escrita usando Delphi 2009. |
VB.NET ::: Dicas & Truques ::: Matemática e Estatística |
Como resolver uma equação do segundo grau em VB.NET - Como calcular Bhaskara em VB.NETQuantidade de visualizações: 739 vezes |
|
Como resolver uma equação do 2º grau usando VB.NET Nesta dica mostrarei como encontrar as raízes de uma equação quadrática, ou seja, uma equação do 2º usando a linguagem VB.NET. Definimos como equação do 2º grau ou equações quadráticas qualquer equação do tipo ax² + bx + c = 0 em que a, b e c são números reais e a ≠ 0. Ela recebe esse nome porque, no primeiro membro da igualdade, há um polinômio de grau dois com uma única incógnita. Note que, dos coeficientes a, b e c, somente o a é diferente de zero, pois, caso ele fosse igual a zero, o termo ax² seria igual a zero, logo a equação se tornaria uma equação do primeiro grau: bx + c = 0. Independentemente da ordem da equação, o coeficiente a sempre acompanha o termo x², o coeficiente b sempre acompanha o termo x, e o coeficiente c é sempre o termo independente. Como resolver uma equação do 2º grau Conhecemos como soluções ou raízes da equação ax² + bx + c = 0 os valores de x que fazem com que essa equação seja verdadeira. Uma equação do 2º grau pode ter no máximo dois números reais que sejam raízes dela. Para resolver equações do 2º grau completas, existem dois métodos mais comuns: a) Fórmula de Bhaskara; b) Soma e produto. O primeiro método é bastante mecânico, o que faz com que muitos o prefiram. Já para utilizar o segundo, é necessário o conhecimento de múltiplos e divisores. Além disso, quando as soluções da equação são números quebrados, soma e produto não é uma alternativa boa. Como resolver uma equação do 2º grau usando Bhaskara Como nosso código VB.NET vai resolver a equação quadrática usando a Fórmula de Bhaskara, o primeiro passo é encontrar o determinante. Veja: \[\Delta =b^2-4ac\] Nem sempre a equação possui solução real. O valor do determinante é que nos indica isso, existindo três possibilidades: a) Se determinante > 0, então a equação possui duas soluções reais. b) Se determinante = 0, então a equação possui uma única solução real. c) Se determinante < 0, então a equação não possui solução real. Encontrado o determinante, só precisamos substituir os valores, incluindo o determinante, na Fórmula de Bhaskara: \[x = \dfrac{- b\pm\sqrt{b^2- 4ac}}{2a}\] Vamos agora ao código VB.NET. Nossa aplicação vai pedir para o usuário informar os valores dos três coeficientes a, b e c e, em seguida, vai apresentar as raizes da equação:
Imports System
Module Program
Sub Main(args As String())
' os coeficientes
Dim a, b, c As Double
' as duas raizes, a imaginaria e o discriminante
Dim raiz1, raiz2, imaginaria, discriminante As Double
' vamos pedir para o usuário informar os valores dos coeficientes
Console.Write("Valor do coeficiente a: ")
a = Double.Parse(Console.ReadLine())
Console.Write("Valor do coeficiente b: ")
b = Double.Parse(Console.ReadLine())
Console.Write("Valor do coeficiente c: ")
c = Double.Parse(Console.ReadLine())
' vamos calcular o discriminante
discriminante = (b * b) - (4 * a * c)
' a equação possui duas soluções reais?
If discriminante > 0 Then
raiz1 = (-b + Math.Sqrt(discriminante)) / (2 * a)
raiz2 = (-b - Math.Sqrt(discriminante)) / (2 * a)
Console.Write("Existem duas raizes: x1 = " & raiz1 _
& " e x2 = " & raiz2)
ElseIf discriminante = 0 Then
' a equação possui uma única solução real?
raiz1 = raiz2 = -b / (2 * a)
Console.Write("Existem duas raizes iguais: x1 = " _
& raiz1 & " e x2 = " & raiz2)
ElseIf discriminante < 0 Then
' a equação não possui solução real?
raiz1 = raiz2 = -b / (2 * a)
imaginaria = Math.Sqrt(-discriminante) / (2 * a)
Console.Write("Existem duas raízes complexas: x1 = " &
raiz1 & " + " & imaginaria & " e x2 = " & raiz2 _
& " - " & imaginaria)
End If
Console.WriteLine(vbCrLf & "Pressione qualquer tecla para sair...")
' pausa o programa
Console.ReadKey()
End Sub
End Module
Ao executar este código VB.NET nós teremos o seguinte resultado: Valor do coeficiente a: 1 Valor do coeficiente b: 2 Valor do coeficiente c: -3 Existem duas raizes: x1 = 1 e x2 = -3 |
C# ::: Dicas & Truques ::: Programação Orientada a Objetos |
C# para iniciantes - Programação orientada a objetos em C#: Classes, objetos, métodos e variáveis de instânciaQuantidade de visualizações: 31001 vezes |
|
A melhor forma de entender a programação orientada a objetos é começar com uma analogia simples. Suponha que você queira dirigir um carro e fazê-lo ir mais rápido pressionado o acelerador. O que deve acontecer antes que você seja capaz de fazer isso? Bem, antes que você possa dirigir um carro, alguém tem que projetá-lo. Um carro geralmente começa com desenhos feitos pelos engenheiros responsáveis por tal tarefa, tal qual a planta de uma casa. Tais desenhos incluem o projeto de um acelerador que possibilita ao carro ir mais rápido. O pedal do acelerador "oculta" os mecanismos complexos responsáveis por fazer o carro ir mais rápido, da mesma forma que o pedal de freio "oculta" os mecanismos que fazem o carro ir mais devagar e o volante "oculta" os mecanismos que fazem com que o carro possa virar para a direita ou esquerda. Isso permite que pessoas com pequeno ou nenhum conhecimento de motores possam facilmente dirigir um carro. Infelizmente, não é possível dirigir o projeto de um carro. Antes que possamos dirigí-lo, o carro deve ser construído a partir do projeto que o descreve. Um carro já finalizado tem um pedal de aceleração de verdade, que faz com que o carro vá mais rápido. Ainda assim, é preciso que o motorista pressione o pedal. O carro não acelerará por conta própria. Agora vamos usar nosso exemplo do carro para introduzir alguns conceitos de programação importantes à programação orientada a objetos. A execução de uma determinada tarefa em um programa exige um método. O método descreve os mecanismos que, na verdade, executam a tarefa. O método oculta tais mecanismos do usuário, da mesma forma que o pedal de aceleração de um carro oculta do motorista os mecanismos complexos que fazem com que um carro vá mais rápido. Em C#, começamos criando uma unidade de programa chamada classe para abrigar um método, da mesma forma que o projeto de um carro abriga o design do pedal de acelerador. Em uma classe fornecemos um ou mais métodos que são projetados para executar as tarefas da classe. Por exemplo, a classe que representa uma conta bancária poderia conter muitos métodos, incluindo um método para depositar dinheiro na conta, outro para retirar dinheiro, um terceiro para verificar o saldo, e assim por diante. Da mesma forma que não podemos dirigir o projeto de um carro, nós não podemos "dirigir" uma classe. Da mesma forma que alguém teve que construir um carro a partir de seu projeto antes que pudessémos dirigí-lo, devemos construir um objeto de uma classe antes de conseguirmos executar as tarefas descritas nela. Quando dirigimos um carro, o pressionamento do acelerador envia uma mensagem ao carro informando-o da tarefa a ser executada (neste caso informando-o de que queremos ir mais rápido). Da mesma forma, enviamos mensagens aos objetos de uma classe. Cada mensagem é uma chamada de método e informa ao objeto qual ou quais tarefas devem ser executadas. Até aqui nós usamos a analogia do carro para introduzir classes, objetos e métodos. Já é hora de saber que um carro possui atributos (propriedades) tais como cor, o número de portas, a quantidade de gasolina em seu tanque, a velocidade atual, etc. Tais atributos são representados como parte do projeto do carro. Quando o estamos dirigindo, estes atributos estão sempre associados ao carro que estamos usando, e cada carro construído a partir do projeto sofrerá variações nos valores destes atributos em um determinado momento. Da mesma forma, um objeto tem atributos associados a ele quando o usamos em um programa. Estes atributos são definidos na classe a partir da qual o objeto é instanciado (criado) e são chamados de variáveis de instância da classe. Veremos agora como definir uma classe em C# e usar um objeto desta classe em um programa. Se estiver usando o Visual C# 2005 ou 2008, a forma mais comum de adicionar uma classe ao seu projeto é clicando com o botão direito no namespace do projeto (o primeiro filho do solution explorer) e escolhendo a opção Add -> Class. Em seguida dê o nome "Cliente.cs" para a classe e clique o botão Add. Imediatamente o código inicial para a classe será exibido, contendo o namespace e alguns using padrões. Agora faça sua classe Cliente parecida com o código abaixo (não altere nada em relação ao namespace):
class Cliente{
private String nome;
// Um método que permite definir um valor
// para a variável privada nome
public void setNome(String nome){
this.nome = nome;
}
// Um método que permite obter o valor
// da variável privada nome
public String getNome(){
return this.nome;
}
}
Agora vamos aprender a usar esta classe a partir da classe principal do programa (aquela que contém o método Main). Veja:
static void Main(string[] args){
// Cria uma instância da classe Cliente
Cliente c = new Cliente();
// Define um nome para o cliente
c.setNome("Osmar J. Silva");
// Obtém o nome do cliente
string nome = c.getNome();
Console.WriteLine(nome);
Console.WriteLine("\n\nPressione uma tecla para sair...");
Console.ReadKey();
}
|
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercício Resolvido de Java - Escreva um programa Java console que solicite ao usuário que informe dois valores inteiros. Em seguida seu programa deverá efetuar a soma dos dois valores e exibí-laQuantidade de visualizações: 13705 vezes |
|
Pergunta/Tarefa: Escreva um programa Java console que solicite ao usuário que informe dois valores inteiros. Em seguida seu programa deverá efetuar a soma dos dois valores e exibí-la. O aplicativo deverá exibir a seguinte saída: Informe o primeiro valor: 7 Informe o segundo valor: 3 A soma dos valores é: 10 Dica: Use a classe Scanner para efetuar a leitura dos valores informados pelo usuário: Sugestão: Que tal modificar a solução para efetuar a leitura e exibir o resultado usando a classe JOptionPane? Resposta/Solução: Veja a resolução do exercício usando a classe Scanner:
public static void main(String[] args){
// não se esqueça de adicionar um import para a classe Scanner
// import java.util.Scanner;
// vamos criar um objeto da classe Scanner
Scanner entrada = new Scanner(System.in);
int a, b; // variáveis que receberão os valores informados
int soma; // variável que guardará a soma dos valores informados
// vamos pedir ao usuário que informe o primeiro valor
System.out.print("Informe o primeiro valor: ");
// vamos ler o primeiro valor
a = Integer.parseInt(entrada.nextLine());
// vamos pedir ao usuário que informe o segundo valor
System.out.print("Informe o segundo valor: ");
// vamos ler o segundo valor
b = Integer.parseInt(entrada.nextLine());
// vamos efetuar a soma
soma = a + b;
// vamos exibir o resultado
System.out.println("A soma dos valores é: " + soma);
}
Veja agora a resolução usando a classe JOptionPane:
public static void main(String[] args){
// não se esqueça de adicionar um import para a classe JOptionPane
// import javax.swing.JOptionPane;
int a, b; // variáveis que receberão os valores informados
int soma; // variável que guardará a soma dos valores informados
// vamos pedir ao usuário que informe o primeiro valor
a = Integer.parseInt(JOptionPane.showInputDialog("Informe o primeiro valor:"));
// vamos pedir ao usuário que informe o segundo valor
b = Integer.parseInt(JOptionPane.showInputDialog("Informe o segundo valor:"));
// vamos efetuar a soma
soma = a + b;
// vamos exibir o resultado
JOptionPane.showMessageDialog(null, "A soma dos valores é: " + soma);
}
|
GNU Octave ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas |
Como calcular o comprimento da hipotenusa em GNU Octave dadas as medidas do cateto oposto e do cateto adjascenteQuantidade de visualizações: 1185 vezes |
Nesta dica mostrarei como é possível usar a linguagem GNU Octave para retornar o comprimento da hipotenusa dadas as medidas do cateto oposto e do cateto adjascente. Vamos começar analisando a imagem a seguir: Veja que, nessa imagem, eu já coloquei os comprimentos da hipotenusa, do cateto oposto e do cateto adjascente. Para facilitar a conferência dos cálculos, eu coloquei também os ângulos theta (que alguns livros chamam de alfa) e beta já devidamente calculados. Então, sabendo que o quadrado da hipotenusa é igual à soma dos quadrados dos catetos (Teorema de Pitógoras): \[c^2 = a^2 + b^2\] Tudo que temos a fazer a converter esta fórmula para código GNU Octave (um script do GNU Octave). Veja:
a <- 20 # medida do cateto oposto
b <- 30 # medida do cateto adjascente
# agora vamos calcular o comprimento da hipotenusa
c <- sqrt(power(a, 2) + power(b, 2))
# e mostramos o resultado
fprintf("O comprimento da hipotenusa é: %f\n\n", c)
Ao executar este código GNU Octave nós teremos o seguinte resultado: O comprimento da hipotenusa é: 36.056000 Como podemos ver, o resultado retornado com o código GNU Octave confere com os valores da imagem apresentada. |
Veja mais Dicas e truques de GNU Octave |
Dicas e truques de outras linguagens |
|
Delphi - Como retornar o índice do item selecionado em um ComboBox do Delphi usando a propriedade ItemIndex |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
