 |
|
|
 Planilha de Dimensionamento de Tubulações
Hidráulicas Água Fria e Água Quente CompletaNossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes. |
||
Você está aqui: Cards de Hidrostática |
||
|
||
 Link para compartilhar na Internet ou com seus amigos: |
||
JavaScript ::: Dicas & Truques ::: Operadores de Manipulação de Bits (Bitwise Operators) |
JavaScript Avançado - Como usar o operador de bits & (E/AND sobre bits) da linguagem JavaScriptQuantidade de visualizações: 1540 vezes |
|
O operador de bits & (E/AND sobre bits) da linguagem JavaScript é usado quando queremos comparar os bits individuais de dois valores integrais (inteiros) e produzir um terceiro resultado. Os bits no resultado serão configurados como 1 se os bits correspondentes nos dois outros valores foram 1. Em caso contrário os bits são configurados como 0. Para quem gosta de Lógica Matemática, ou a Tabela Verdade da Lógica de Boole, vai se lembrar do conectivo "^", que diz que a proposição resultante da conjunção só será verdadeira quando as proposições simples individuais forem verdadeiras. O operador de bits & do JavaScript é similar ao conectivo "^" da Lógica Proposicional. Vamos analisar os seguintes valores binários: a) 0101 (5 decimal) b) 0100 (4 decimal) Quando aplicamos o operador & nestes dois valores teremos o seguinte resultado: 0101 0100 ---- 0100 Veja que o resultado é 0100, uma vez que apenas o segundo bit de cada valor está configurado como 1. Vamos ver isso em JavaScript agora. Observe o seguinte trecho de código:
<html>
<head>
<title>Manipulação de Bits em JavaScript</title>
</head>
<body>
<script type="text/javascript">
var a = 5;
var b = 4;
var c = a & b;
// exibe o resultado (em binário e em decimal)
document.writeln("a = " + obterBits(a) + " (" + a + ")");
document.writeln("<br>b = " + obterBits(b) + " (" + b + ")");
document.writeln("<br>a & b = " + obterBits(c) + " (" + c + ")");
// função auxiliar que converte um decimal em sua representação em bits
function obterBits(valor){
var mascara = 1 << 31; // 10000000 00000000 00000000 00000000
var buffer = ""; // um buffer para guardar os bits dos bytes
for(var i = 1; i <= 32; i++){
// compara os bits individuais dos dois valores inteiros
if((valor & mascara) == 0){
buffer = buffer + "0";
}
else{
buffer = buffer + "1";
}
valor = valor << 1; // desloca uma posição para a esquerda
// Cada troca à esquerda corresponde à multiplicação do
// valor por 2
if(i % 8 == 0){ // completou um byte?
buffer = buffer + " ";
}
}
return buffer;
}
</script>
</body>
</html>
Ao executar este código teremos o seguinte resultado:
a = 00000000 00000000 00000000 00000101 (5)
b = 00000000 00000000 00000000 00000100 (4)
a & b = 00000000 00000000 00000000 00000100 (4)
|
Java ::: Java para Engenharia ::: Geometria Analítica e Álgebra Linear |
Como converter Coordenadas Cartesianas para Coordenadas Polares usando Java - Java para EngenhariaQuantidade de visualizações: 2477 vezes |
|
Nesta nossa série de Java para Geometria Analítica e Álgebra Linear, mostrarei um código 100% funcional para fazer a conversão entre coordenadas cartesianas e coordenadas polares. Esta operação é muito frequente em computação gráfica e é parte integrante das disciplinas dos cursos de Engenharia (com maior ênfase na Engenharia Civil). Na matemática, principalmente em Geometria e Trigonometria, o sistema de Coordenadas no Plano Cartesiano, ou Espaço Cartesiano, é um sistema que define cada ponto em um plano associando-o, unicamente, a um conjuntos de pontos numéricos. Dessa forma, no plano cartesiano, um ponto é representado pelas coordenadas (x, y), com o x indicando o eixo horizontal (eixo das abscissas) e o y indicando o eixo vertical (eixo das ordenadas). Quando saímos do plano (espaço 2D ou R2) para o espaço (espaço 3D ou R3), temos a inclusão do eixo z (que indica profundidade). Já o sistema de Coordenadas Polares é um sistema de coordenadas em duas dimensões no qual cada ponto no plano é determinado por sua distância a partir de um ponto de referência conhecido como raio (r) e um ângulo a partir de uma direção de referência. Este ângulo é normalmente chamado de theta (__$\theta__$). Assim, um ponto em Coordenadas Polares é conhecido por sua posição (r, __$\theta__$). Antes de prosseguirmos, veja uma imagem demonstrando os dois sistemas de coordenadas:  A fórmula para conversão de Coordenadas Cartesianas para Coordenadas Polares é: __$r = \sqrt{x^2+y2}__$ __$\theta = \\arctan\left(\frac{y}{x}\right)__$ E aqui está o código Java completo que recebe as coordenadas cartesianas (x, y) e retorna as coordenadas polares (r, __$\theta__$):
package arquivodecodigos;
import java.util.Scanner;
public class Estudos{
public static void main(String args[]){
Scanner entrada = new Scanner(System.in);
// vamos ler as coordenadas cartesianas
System.out.print("Valor de x: ");
double x = Double.parseDouble(entrada.nextLine());
System.out.print("Valor de y: ");
double y = Double.parseDouble(entrada.nextLine());
// vamos calcular o raio
double raio = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
// agora calculamos o theta (ângulo) em radianos
double theta = Math.atan2(y, x);
// queremos o ângulo em graus também
double angulo_graus = 180 * (theta / Math.PI);
// e exibimos o resultado
System.out.println("As Coordenadas Polares são:\n" +
"raio = " + raio + ", theta = " + theta + ", ângulo em graus = " +
angulo_graus);
}
}
Ao executar este código nós teremos o seguinte resultado: Valor de x: -1 Valor de y: 1 As Coordenadas Polares são: raio = 1.4142135623730951, theta = 2.356194490192345, ângulo em graus = 135.0 Veja que as coordenadas polares equivalentes são (__$\sqrt{2}__$, __$\frac{3\pi}{4}__$), com o theta em radianos. Sim, os professores das disciplinas de Geometria Analítica e Álgebra Linear, Física e outras gostam de escrever os resultados usando raizes e frações em vez de valores reais. |
Delphi ::: Dicas & Truques ::: Arquivos e Diretórios |
Como ler todo o conteúdo de um arquivo texto usando Delphi - As funções AssignFile(), ReadLn() e Eof() do DelphiQuantidade de visualizações: 32399 vezes |
|
Nesta dica mostro como usar o Delphi para ler todo o conteúdo de um arquivo texto. Esta leitura será feita linha a linha e adicionaremos cada linha a um TMemo à medida que ela for lida. O primeiro passo para se ler um arquivo texto usando Delphi é declarar uma variável do tipo TextFile. Em seguida usamos a procedure AssignFile() para associar a variável TextFile ao arquivo em disco. Como queremos ler o conteúdo do arquivo, a função Reset() deve ser usada. Esta função abre o arquivo texto fornecido e posiciona o cursor de leitura no início do arquivo. A partir daí podemos usar um laço while e a função ReadLn() para ler cada linha do arquivo. Note o uso da função Eof() para testarmos se o ponteiro de leitura ainda não atingiu o fim do arquivo. Veja o exemplo para um melhor entendimento:
procedure TForm1.Button1Click(Sender: TObject);
var
arquivo: TextFile;
linha: String;
begin
// vamos fazer uma ligação entre a variável arquivo e o
// arquivo que queremos ler
AssignFile(arquivo, 'C:\arquivo de codigos\dados.txt');
// vamos abrir o arquivo em modo leitura
Reset(arquivo);
// vamos ler cada linha e adicioná-la a um Memo
while not Eof(arquivo) do
begin
ReadLn(arquivo, linha);
Memo1.Lines.Add(linha);
end;
// hora de fechar o arquivo
CloseFile(arquivo);
end;
Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009. |
Java ::: Pacote java.awt ::: Graphics |
Como desenhar texto na superfície de uma JLabel do Java Swing usando o método drawString() da classe GraphicsQuantidade de visualizações: 12334 vezes |
A classe Graphics possui um método chamado drawString() que é usado para desenhar uma string na superfície de um componente. Veja a assinatura deste método:public abstract void drawString(String str, int x,int y) Como podemos ver, só precisamos fornecer a string a ser desenhada, a coordenada x e a coordenada y. Estas coordenadas são obtidas a partir do canto superior esquerdo do componente no qual desenharemos. O trecho de código abaixo mostra como desenhar a string "Arquivo de Códigos" em um JLabel:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Estudos extends JFrame{
JLabel label;
public Estudos() {
super("Desenhando em um JLabel");
Container c = getContentPane();
c.setLayout(new BorderLayout());
// Cria um JLabel
label = new JLabel();
c.add(label, BorderLayout.CENTER);
// Cria um botão
JButton btn = new
JButton("Desenhar uma string");
btn.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
// Desenha uma string no JLabel
Graphics graphics = label.getGraphics();
graphics.drawString("Arquivo de Códigos",
20, 50);
}
}
);
// Adiciona o botão à janela
c.add(btn, BorderLayout.SOUTH);
setSize(350, 250);
setVisible(true);
}
public static void main(String args[]){
Estudos app = new Estudos();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Há algo de interessante neste código. Se você maximizar, minimizar ou redimensionar a janela verá que o desenho é apagado. Isso acontece porque todas as vezes que a janela sofre alguma alteração, ela é pintada novamente, juntamente com seus componentes filhos. Se você deseja que o desenho seja feito automaticamente novamente, é melhor fazer uma sub-classe do componente desejado e sobrescrever seu método paintComponent(). Nesta mesma seção você encontrará exemplos de como fazer isso. |
C# ::: Datas e Horas ::: DateTime |
Como construir uma data em C# usando o objeto DateTime e fornecendo o dia, mês e ano da data desejadaQuantidade de visualizações: 7560 vezes |
Aplicações que lidam com datas e horas geralmente precisam ser capazes de criar suas próprias datas. Isso pode ser feito com o auxílio de um dos vários construtores da estrutura DateTime. Para esta dica eu mostrarei como criar uma data no formato 23/05/2008. O construtor a ser usado é:DateTime(Int32, Int32, Int32) Este construtor pede valores inteiros representando o ano, mês e dia da data que queremos construir e retorna um objeto DateTime representando a data recém-construida. Veja um exemplo:
static void Main(string[] args){
// cria um objeto DateTime para a data 10/04/2008
DateTime data = new DateTime(2008, 4, 10);
// exibe o resultado
System.Console.WriteLine(data.ToString("dd/MM/yyyy"));
// pausa o programa
Console.ReadKey();
}
Note que, quando usamos este construtor, a parte do DateTime relativa às horas é inicializada como meia-noite. Tome cuidade. Este método pode lançar exceções dos tipos ArgumentOutOfRangeException e ArgumentException se os valores fornecidos para o ano, mês e dia estiverem fora das faixas permitidas. |
Desafios, Exercícios e Algoritmos Resolvidos de C# |
Veja mais Dicas e truques de C# |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
