Dúvidas, comentários e doaçoes: +55 62 9 8513 2505

Planilha de Dimensionamento de Tubulações Hidráulicas Água Fria e Água Quente Completa
Nossa 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 Engenharia Civil - Construção Civil
Card 1 de 28
Fases de uma obra

A Planta de Localização (escala usual 1:200) identifica a posição da obra no terreno. Serve para implantar o projeto.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

R ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como calcular o coeficiente angular de uma reta em R dados dois pontos no plano cartesiano

Quantidade de visualizações: 2054 vezes
O Coeficiente Angular de uma reta é a variação, na vertical, ou seja, no eixo y, pela variação horizontal, no eixo x. Sim, isso mesmo. O coeficiente angular de uma reta tem tudo a ver com a derivada, que nada mais é que a taxa de variação de y em relação a x.

Vamos começar analisando o seguinte gráfico, no qual temos dois pontos distintos no plano cartesiano:



Veja que o segmento de reta AB passa pelos pontos A (x=3, y=6) e B (x=9, y=10). Dessa forma, a fórmula para obtenção do coeficiente angular m dessa reta é:

\[\ \text{m} = \frac{y_2 - y_1}{x_2 - x_1} = \frac{\Delta y}{\Delta x} = tg \theta \]

Note que __$\Delta y__$ e __$\Delta x__$ são as variações dos valores no eixo das abscissas e no eixo das ordenadas. No triângulo retângulo que desenhei acima, a variação __$\Delta y__$ se refere ao comprimento do cateto oposto e a variação __$\Delta y__$ se refere ao comprimento do cateto adjascente.

Veja agora o trecho de código na linguagem R que solicita as coordenadas x e y dos dois pontos, efetua o cálculo e mostra o coeficiente angular m da reta que passa pelos dois pontos:

# x e y do primeiro ponto
x1 <- readline("Coordenada x do primeiro ponto: ")
y1 <- readline("Coordenada y do primeiro ponto: ")
x1 <- as.numeric(x1)
y1 <- as.numeric(y1)

# x e y do segundo ponto
x2 <- readline("Coordenada x do segundo ponto: ")
y2 <- readline("Coordenada y do segundo ponto: ")
x2 <- as.numeric(x2)
y2 <- as.numeric(y2)

# agora vamos calcular o coeficiente angular
m <- (y2 - y1) / (x2 - x1)

# mostramos o resultado
paste("O coeficiente angular é:", m)

Ao executar este código em linguagem R nós teremos o seguinte resultado:

[1] "O coeficiente angular é: 0.666666666666667"

Veja agora como podemos calcular o coeficiente angular da reta que passa pelos dois pontos usando o Teorema de Pitágoras. Note que agora nós estamos tirando proveito da tangente do ângulo Theta (__$\theta__$), também chamado de ângulo Alfa ou Alpha (__$\alpha__$):

# x e y do primeiro ponto
x1 <- readline("Coordenada x do primeiro ponto: ")
y1 <- readline("Coordenada y do primeiro ponto: ")
x1 <- as.numeric(x1)
y1 <- as.numeric(y1)

# x e y do segundo ponto
x2 <- readline("Coordenada x do segundo ponto: ")
y2 <- readline("Coordenada y do segundo ponto: ")
x2 <- as.numeric(x2)
y2 <- as.numeric(y2)

# vamos obter o comprimento do cateto oposto
cateto_oposto <- y2 - y1
# e agora o cateto adjascente
cateto_adjascente <- x2 - x1
# vamos obter o ângulo tetha, ou seja, a inclinação da hipetunesa
# (em radianos, não se esqueça)
tetha <- atan2(cateto_oposto, cateto_adjascente)
# e finalmente usamos a tangente desse ângulo para calcular
# o coeficiente angular
tangente <- tan(tetha)

# mostramos o resultado
paste("O coeficiente angular é:", tangente)

Ao executar este código você verá que o resultado é o mesmo. No entanto, fique atento às propriedades do coeficiente angular da reta:

1) O coeficiente angular é positivo quando a reta for crescente, ou seja, m > 0;

2) O coeficiente angular é negativo quando a reta for decrescente, ou seja, m < 0;

3) Se a reta estiver na horizontal, ou seja, paralela ao eixo x, seu coeficiente angular é zero (0).

4) Se a reta estiver na vertical, ou seja, paralela ao eixo y, o coeficiente angular não existe.


LISP ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas

Como converter radianos em graus em LISP - Trigonometria em LISP

Quantidade de visualizações: 1168 vezes
Todas as funções trigonométricas em Common Lisp (ou AutoLISP, para programadores AutoCAD) recebem seus argumentos em radianos, em vez de graus. Um exemplo disso é a função sin(). Esta função recebe o ângulo em radianos e retorna o seu seno.

No entanto, há momentos nos quais precisamos retornar alguns valores como graus. Para isso é importante sabermos fazer a conversão de radianos para graus. Veja a fórmula abaixo:

\[Graus = Radianos \times \frac{180}{\pi}\]

Agora veja como esta fórmula pode ser escrita em código LISP:

; programa LISP que converte radianos em graus
(let((radianos)(graus))
  ; valor em radianos
  (setq radianos 1.5)
  ; obtém o valor em graus
  (setq graus (* radianos (/ 180 pi)))
  
  ; mostra o resultado
  (format t "~F radianos em graus é ~F" radianos
    graus)
)

Ao executarmos este código LISP nós teremos o seguinte resultado:

1.5 radianos convertidos para graus é 85.94366926962348

Para fins de memorização, 1 radiano equivale a 57,2957795 graus.


Python ::: cmath Python Module (Módulo Python cmath para números complexos) ::: Números Complexos (Complex Numbers)

Como converter um número complexo na forma retangular para a forma polar usando Python

Quantidade de visualizações: 2810 vezes
Quando estamos efetuando cálculos envolvendo números complexos, é comum precisarmos converter da forma retangular para a forma polar, e vice-versa.

Um número complexo na forma retangular apresenta o seguinte formato:

7 + j5


onde 7 é a parte real e 5 é a parte imaginária. Note que usei a notação "j" em vez de "i" para a parte imaginária, uma vez que a notação "j" é a mais comum na engenharia.

O número complexo na forma polar, por sua vez, é composto pelo raio e pela fase (phase), que é o ângulo theta (ângulo da inclinação da hipotenusa em relação ao cateto adjascente).

O raio, representado por r, é o módulo do vetor cujas coordenadas são formadas pela parte real e a parte imaginária do número complexo. A parte real se encontra no eixo das abcissas (x) e a parte imaginária fica no eixo das ordenadas (y).

Veja agora o código Python completo que lê a parte real e a parte imaginária de um número complexo e o exibe na forma polar:

# vamos importar o módulo de matemática de números complexos
import cmath

# método principal
def main():
  # vamos ler a parte real e a parte imaginária do
  # número complexo
  real = float(input("Parte real do número complexo: "))
  imaginaria = float(input("Parte imaginária do número complexo: "))

  # constrói o número complexo
  z = complex(real, imaginaria)

  # mostra o valor absoluto na forma polar
  print ("Valor absoluto (raio ou módulo): ", abs(z))
  # mostra a fase do número complexto na forma polar
  print("Fase em radianos: ", cmath.phase(z))
  print("Fase em graus: ", cmath.phase(z) * (180 / cmath.pi))
  
if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

Parte real do número complexo: 3
Parte imaginária do número complexo: -4
Valor absoluto (raio ou módulo): 5.0
Fase em radianos: -0.9272952180016122
Fase em graus: -53.13010235415598


LISP ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como testar uma condição em Lisp usando a macro if

Quantidade de visualizações: 1529 vezes
Nesta dica mostrarei como podemos usar a macro if da linguagem Common Lisp para testar uma condição. Por se tratar de um exemplo básico, não mostrarei um caminho alternativo, ou seja, a mensagem será exibido somente se a condição for satisfeita. Em outras dicas eu complemento com o desvio opcional.

Veja um exemplo no qual solicitamos um número ao usuário e informamos se o valor lido é maior que 10:

; Vamos definir as variáveis que vamos
; usar no programa
(defvar numero)

; Este é o programa principal
(defun Estudos()
  ; Vamos ler o número
  (princ "Informe um número: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  ; atribui o valor lido à variável numero
  (setq numero (read))
  
  ; vamos testar se este número é maior que 10
  (if (> numero 10)
    (format t "~D é maior que 10~%" numero))
  
  ; E mostramos o número informado
  (format t "O número informado foi: ~D" numero)
)

; Auto-executa a função Estudos()
(Estudos)

Ao executar este código Common Lisp nós teremos o seguinte resultado:

Informe um número: 12
12 é maior que 10
O número informado foi: 12


Python ::: Pandas Python Library (Biblioteca Python Pandas) ::: Input e Output (Entrada e Saída)

Como usar o método read_csv() do Pandas da linguagem Python para carregar um dataset e retorná-lo como um DataFrame

Quantidade de visualizações: 5639 vezes
Quando estamos desenvolvendo soluções em Data Science ou Machine Learning, é comum precisarmos carregar dados contidos em arquivos .csv (nos quais os registros são separados por vírgulas ou ponto-e-vírgula). Para isso podemos usar o método read_csv() da biblioteca Pandas do Python.

Veja um exemplo no qual usamos o método read_csv() para carregar um dataset e depois exibir o DataFrame resultante. Para isso usaremos uma amostra de dados de empréstimos aprovados ou recusados. O arquivo .csv pode ser baixado aqui.

Eis o código:

# importamos a biblioteca Pandas
import pandas as pd

def main():
  # vamos carregar os dados do arquivo .csv
  dados = pd.read_csv("C:\\estudos_python\\emprestimos.csv",
   delimiter=";")

  # vamos mostrar o DataFrame resultante
  print(dados)

if __name__== "__main__":
  main()

Quando executarmos este código nós teremos um resultado parecido com:

    id nome       idade sexo renda valor parc pont ap
0    1 MIGUEL728   24    M   1800  12500  30   34   S
1    2 RAUL46      61    M   2300  10000  24   59   S
2    3 JONAS264    28    M    800  12500  36   59   N
3    4 LETICIA135  71    F   1800  10000  36   13   N
4    5 CARLOS931   60    F   4000   2000   6   10   N
.. ...   ...    ...  ...    ...    ...   ...   ... ..
9   96 ANGELA391   91    F   4000  12500  12   33   N
96  97 PEDRO764    50    M  10200   2500  12    1   N
97  98 ADRIANA175  41    F   4000   2000  36   77   S
98  99 ROSA666     42    F   1800  20000  24   74   N
99 100 SARA653     36    F    970  11000  12   42   N

[100 rows x 9 columns]


Note que aqui nós temos uma amostra de 100 registros e cada registro possui 9 colunas. Se você quiser ver todos os 100 registros, troque a linha:

print(dados)

por

print(dados.to_string())

Para finalizar, note que forneci ";" como delimitador para o método read_csv().


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

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby


E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser. Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book Apenas R$ 19,90


© 2026 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 18 usuários muito felizes estudando em nosso site.