![]() |
|
|
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 AutoCAD Civil 3D |
||
|
||
|
|
||
C ::: Dicas & Truques ::: Ponteiros, Referências e Memória |
Como alocar memória dinâmica usando a função calloc() da linguagem CQuantidade de visualizações: 19534 vezes |
A função calloc() é bem parecida com a função malloc() e também é usada em C para alocarmos um bloco de memória. A diferença é que calloc() recebe a quantidade de elementos e o número de bytes do elemento e retorna um ponteiro do tipo void (genérico) para o início do bloco de memória obtido. Veja sua assinatura:void *calloc(size_t n, size_t size); Se a memória não puder se alocada, um ponteiro nulo (NULL) será retornado. É importante se lembrar de alguns conceitos antes de usar esta função. Suponhamos que você queira alocar memória para um único inteiro. Você poderia ter algo assim: // aloca memória para um int ponteiro = calloc(1, 4); Embora este código esteja correto, não é um boa idéia assumir que um inteiro terá sempre 4 bytes. Desta forma, é melhor usar o operador sizeof() para obter a quantidade de bytes em um inteiro em uma determinada arquitetura. Veja: // aloca memória para um int ponteiro = calloc(1, sizeof(int)); Eis o código completo para um aplicativo C que mostra como alocar memória para um inteiro e depois atribuir e obter o valor armazenado no bloco de memória alocado:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
// ponteiro para uma variável do tipo inteiro
int *ponteiro;
// aloca memória para um int
ponteiro = calloc(1, sizeof(int));
// testa se a memória foi alocada com sucesso
if(ponteiro)
printf("Memoria alocada com sucesso.\n");
else
printf("Nao foi possivel alocar a memoria.\n");
// atribui valor à memória alocada
*ponteiro = 45;
// obtém o valor atribuído
printf("Valor: %d\n\n", *ponteiro);
// libera a memória
free(ponteiro);
system("PAUSE");
return 0;
}
Uma aplicação interessante da função calloc() é quando precisamos construir uma matriz dinâmica. Veja como isso é feito no código abaixo:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int i;
// quantidade de elementos na matriz
int quant = 10;
// ponteiro para o bloco de memória
int *ponteiro;
// aloca memória para uma matriz de inteiros
ponteiro = calloc(quant, sizeof(int));
// testa se a memória foi alocada com sucesso
if(ponteiro)
printf("Memoria alocada com sucesso.\n");
else{
printf("Nao foi possivel alocar a memoria.\n");
exit(1);
}
// atribui valores aos elementos do array
for(i = 0; i < quant; i++){
ponteiro[i] = i * 2;
}
// exibe os valores
for(i = 0; i < quant; i++){
printf("%d ", ponteiro[i]);
}
// libera a memória
free(ponteiro);
printf("\n\n");
system("PAUSE");
return 0;
}
|
VB.NET ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição |
Exercícios Resolvidos de VB.NET - Um laço for que solicita ao usuário 10 números inteiros e mostra o menor e o maior valor informadoQuantidade de visualizações: 937 vezes |
|
Pergunta/Tarefa: Escreva um programa VB.NET que usa o laço for para solicitar ao usuário que informe 10 números inteiros. Em seguida mostre o maior e o menor valor lido. Não é permitido usar vetores ou matrizes (arrays). Sua saída deve ser parecida com: Informe o 1º valor: 5 Informe o 2º valor: 1 Informe o 3º valor: 20 Informe o 4º valor: 6 Informe o 5º valor: 3 Informe o 6º valor: 4 Informe o 7º valor: 7 Informe o 8º valor: 12 Informe o 9º valor: 9 Informe o 10º valor: 8 O maior valor lido foi: 20 O menor valor lido foi: 1 Veja a solução comentada deste exercício usando a linguagem VB.NET:
Imports System
Module Program
Sub Main(args As String())
Dim valor As Integer ' guarda o valor lido
Dim maior, menor As Integer ' variáveis que guardarão
' o maior e o menor valor lido
' vamos pedir ao usuário que informe 10 valores inteiros
For i As Integer = 1 To 10 Step 1
Console.Write("Informe o " & i & "º valor: ")
valor = Integer.Parse(Console.ReadLine())
' esta é a primeira iteração do laço? se for vamos assumir que o
' maior e menor valor lido são o primeiro valor informado
If i = 1 Then
maior = valor
menor = valor
Else ' não é a primeira iteração
' vamos verificar se é maior que o valor atual da variável maior
If valor > maior Then
maior = valor
End If
' vamos verificar se é menor que o valor atual da variável menor
If valor < menor Then
menor = valor
End If
End If
Next
' vamos exibir o maior e o menor valor lido
Console.WriteLine(vbCrLf & "O maior valor lido foi: " & maior)
Console.WriteLine("O menor valor lido foi: " & menor)
Console.WriteLine(vbCrLf & "Pressione qualquer tecla para sair...")
' pausa o programa
Console.ReadKey()
End Sub
End Module
|
C ::: Dicas & Truques ::: Ordenação e Pesquisa (Busca) |
Ordenação e pesquisa em C - Como ordenar um vetor de inteiros usando a ordenação Insertion Sort (Ordenação por Inserção)Quantidade de visualizações: 3450 vezes |
|
A ordenação Insertion Sort, ou Ordenação por Inserção, possui uma complexidade de tempo de execução igual à ordenação Bubble Sort (Ordenação da Bolha), ou seja, O(n2). Embora mais rápido que o Bubble Sort, e ser um algorítmo de ordenação quadrática, a ordenação Insertion Sort é bastante eficiente para problemas com pequenas entradas, sendo o mais eficiente entre os algoritmos desta ordem de classificação, porém, nunca recomendada para um grande conjunto de dados. A forma mais comum para o entendimento da ordenação Insertion Sort é compará-la com forma pela qual algumas pessoas organizam um baralho num jogo de cartas. Imagine que você está jogando as cartas. Você está com as cartas na mão e elas estão ordenadas. Você recebe uma nova carta e deve colocá-la na posição correta da sua mão de cartas, de forma que as cartas obedeçam à ordenação. A cada nova carta adicionada à sua mão de cartas, a nova carta pode ser menor que algumas das cartas que você já tem na mão ou maior, e assim, você começa a comparar a nova carta com todas as cartas na sua mão até encontrar sua posição correta. Você insere a nova carta na posição correta, e, novamente, a sua mão é composta de cartas totalmente ordenadas. Então, você recebe outra carta e repete o mesmo procedimento. Então outra carta, e outra, e assim em diante, até não receber mais cartas. Esta é a ideia por trás da ordenação por inserção. Percorra as posições do vetor (array), começando com o índice 1 (um). Cada nova posição é como a nova carta que você recebeu, e você precisa inseri-la no lugar correto no sub-vetor ordenado à esquerda daquela posição. Vamos ver a implementação na linguagem C agora? Observe o seguinte código, no qual temos um vetor de inteiros com os elementos {4, 6, 2, 8, 1, 9, 3, 0, 11}:
#include <stdio.h>
#include <stdlib.h>
// função que permite ordenar um vetor de inteiros
// usando a ordenação Insertion Sort
void insertionSort(int vetor[], int tam){
int i, temp, j;
// este laço varre os elementos a partir do segundo
// elemento, ou seja, o índice 1
for(i = 1; i < tam; i++){
// guardamos o elemento atual em temp
temp = vetor[i];
for(j = i; ((j > 0) && (vetor[j - 1] > temp)); j--){
vetor[j] = vetor[j - 1]; // houve uma troca
}
vetor[j] = temp; // colocamos temp em seu devido lugar
}
}
int main(int argc, char *argv[]){
int valores[] = {4, 6, 2, 8, 1, 9, 3, 0, 11};
int i, tamanho = 9;
// imprime a matriz sem a ordenação
puts("Sem ordenação:\n");
for(i = 0; i < 9; i++){
printf("%d ", valores[i]);
}
// vamos ordenar a matriz
insertionSort(valores, tamanho);
// imprime a matriz ordenada
puts("\n\nOrdenada usando Insertion Sort:\n");
for(i = 0; i < 9; i++){
printf("%d ", valores[i]);
}
printf("\n\n");
system("PAUSE");
return 0;
}
Ao executar este código C nós teremos o seguinte resultado: Sem ordenação: 4 6 2 8 1 9 3 0 11 Ordenada usando Insertion Sort: 0 1 2 3 4 6 8 9 11 |
C++ ::: Win32 API (Windows API) ::: Arquivos e Diretórios |
Como obter o diretório atual usando a função GetCurrentDirectory() da API do Windows - C++ e WinAPIQuantidade de visualizações: 10307 vezes |
|
Nesta dica mostrarei como chamar, a partir de um programa C++, a função GetCurrentDirectory() da API do Windows com o propósito de obter o diretório atual, ou seja, o diretório de trabalho da nossa aplicação. Esta função é declarada no header winbase.h (que vem junto quando fazemos include do header windows.h). Veja o exemplo completo:
#include <cstdlib>
#include <iostream>
#include <windows.h>
using namespace std;
int main(int argc, char *argv[])
{
// buffer que receberá o nome do diretório
TCHAR szDirAtual[MAX_PATH];
// chama a função GetCurrentDirectory
GetCurrentDirectory(MAX_PATH, szDirAtual);
// Exibe o resultado
cout << "O diretório atual é " << szDirAtual << "\n\n";
system("PAUSE");
return EXIT_SUCCESS;
}
Ao executar este código nós teremos o seguinte resultado: O diretório atual é C:\estudos_c++ |
Python ::: Python para Engenharia ::: Cálculo Diferencial e Integral |
Como calcular o limite de uma função usando Python e a biblioteca Sympy - Python para EngenhariaQuantidade de visualizações: 5009 vezes |
|
Como calcular o limite de uma função usando Python e a biblioteca Sympy Citando a Wikipédia: Na matemática, o limite de uma função é um conceito fundamental em cálculo e análise sobre o comportamento desta função quando próxima a um valor particular de sua variável independente. Informalmente, diz-se que __$\text{L}__$ é o limite da função __$\text{f(x)}__$ quando __$\text{x}__$ tende a __$\text{p}__$, escreve-se \[ \lim_{x \to p} f(x) = L \] quando __$\text{f(x)}__$ está arbitrariamente próximo de __$\text{L}__$ para todo __$\text{x}__$ suficientemente próximo de __$\text{p}__$. O conceito de limite pode ser estendido para funções de varias variáveis. A biblioteca SymPy da linguagem Python facilita muito o trabalho de se calcular limites. É claro que é sempre uma boa idéia saber calcular o limite de uma função "na mão" mesmo, até para sabermos se nosso código Python está correto. No entanto, em algumas situações, lançar mão da função limit() da SymPy nos poupará um tempo incrível. Dessa forma, a sintáxe para o cálculo do limite na SymPy segue o padrão limit(função, variável, ponto). Então, se quisermos calcular o limite de f(x) com x tendendo a 0, só precisamos fazer limit(f, x, 0). Vamos colocar esse conhecimento em prática então? Veja o seguinte limite: \[ \lim_{x \to 1} 5x^2 + 2x \] Agora observe o código Python completo que calcula e retorna o limite desta função:
# vamos importar a biblioteca SymPy
from sympy import *
def main():
# vamos definir o símbolo x
x = symbols("x")
# definimos a função
f = (5 * x ** 2) + (2 * x)
# finalmente calculamos o limite
limite = limit(f, x, 1)
# e mostramos o resultado
print("O limite da função é: %f." % limite)
if __name__== "__main__":
main()
Ao executar este código nós teremos o seguinte resultado: O limite da função é: 7.000000. Logo, o limite da função no ponto __$\text{x}__$ = 1 vale 7, em outras palavras, 7 é o valor que __$f(5x^2 + 2x)__$ deveria ter em 1 para ser contínua nesse ponto. Vamos ver mais um exemplo? Observe o seguinte limite: \[ \lim_{x \to 1} \left(\frac{x^2 - 1}{x - 1}\right) \] Aqui temos um situação interessante. Note que temos que fazer uma manipulação algébrica na expressão, fatorando os termos. Porém, mesmo em situações assim o método limit() da Sympy consegue interpretar a expressão simbólica corretamente e nos devolver o limite esperado. Veja o código Python completo:
# vamos importar a biblioteca SymPy
from sympy import *
def main():
# vamos definir o símbolo x
x = symbols("x")
# definimos a função
f = (x ** 2 - 1) / (x - 1)
# finalmente calculamos o limite
limite = limit(f, x, 1)
# e mostramos o resultado
print("O limite da função é: %f." % limite)
if __name__== "__main__":
main()
Ao executar este código Python nós teremos o seguinte resultado: O limite da função é: 2.000000. |
Desafios, Exercícios e Algoritmos Resolvidos de Python |
Veja mais Dicas e truques de Python |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |




