Ofereço ajuda em Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD
+55 (062) 98553-6711
Ofereço ajuda em PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO
+55 (062) 98243-1195

Você está aqui: Lisp ::: Dicas & Truques ::: Matemática e Estatística

Como retornar o valor de PI em LISP usando a função pi()

Quantidade de visualizações: 793 vezes
A constante PI, ou simplesmente PI, é o valor da razão entre a circunferência de qualquer círculo e seu diâmetro. Veja a figura abaixo para melhor entendimento:



Em LISP, o PI pode ser obtido por meio do uso da função pi(). Seu valor é algo como: 3,14159...

Veja o trecho de código abaixo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; vamos obter o valor da constante PI em LISP
(let (valor_pi)
  ; obtemos o valor da constante PI e guardamos
  ; na variável valor_pi
  (setq valor_pi (* 1 pi))
  ; vamos mostrar o resultado
  (format t "O valor de PI é: ~D" valor_pi)  
)

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

O valor de PI é: 3.141592653589793

É importante manter em mente que nem todas as implementações de LISP possuem a função pi(). Para esta dica eu usei a Common Lisp no compilador SBCL 2.2.3, uma implementação da ANSI Common Lisp.

Link para compartilhar na Internet ou com seus amigos:

Lisp ::: Dicas & Truques ::: Matemática e Estatística

Como calcular raiz quadrada em Lisp usando a função sqrt

Quantidade de visualizações: 1279 vezes
A raiz quadrada de um algarismo é dada por um número positivo n, que ao ser elevado ao quadrado (multiplicado por ele mesmo), se iguala a x. Na área da matemática, a raiz quadrada auxilia na resolução de vários problemas, entre eles as equações de segundo grau e o Teorema de Pitágoras.

Relembrando que a raiz quadrada é o inverso da potenciação com expoente dois, temos que:

\[\sqrt{9} = 3\]

então, pela potenciação:

\[3^2 = 9\]

Agora veremos como calcular a raiz quadrada usando a função sqrt da linguagem Common Lisp. Veja o código completo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

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

; Este o programa principal
(defun RaizQuadrada()
  ; 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))
  
  ; calcula a raiz quadrada do número informado
  (setq raiz (sqrt numero))
  
  ; E mostramos o resultado
  (format t "A raiz quadrada de ~F é ~F" numero
    raiz)
)

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

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

Informe um número: 9
A raiz quadrada é: 3

É importante observar que, se fornecermos um valor negativo para a função sqrt da Common List não teremos um erro, como em muitas outras linguagens de programação. Em vez disso, o valor retornado será em forma de um número complexo. Veja:

Informe um número: -9
A raiz quadrada de -9.0 é #C(0.0 3.0)


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

Como calcular o cosseno de um ângulo em LISP e AutoLISP (AutoCAD) usando a função cos() - Calculadora de cosseno em LISP

Quantidade de visualizações: 627 vezes
Em geral, quando falamos de cosseno, estamos falando do triângulo retângulo de Pitágoras (Teorema de Pitágoras). A verdade é que podemos usar a função cosseno disponível nas linguagens de programação para calcular o cosseno de qualquer número, mesmo nossas aplicações não tendo nenhuma relação com trigonometria.

No entanto, é sempre importante entender o que é a função cosseno. Veja a seguinte imagem:



Veja que temos um triângulo retângulo com as medidas já calculadas para a hipotenusa e os dois catetos, assim como os ângulos entre eles.

Assim, o cosseno é a razão entre o cateto adjascente e a hipotenusa, ou seja, o cateto adjascente dividido pela hipotenusa. Veja a fórmula:

\[\text{Cosseno} = \frac{\text{Cateto adjascente}}{\text{Hipotenusa}} \]

Então, se dividirmos 30 por 36.056 (na figura eu arredondei) nós teremos 0.8320, que é a razão entre o cateto adjascente e a hipotenusa (em radianos).

Agora, experimente calcular o arco-cosseno de 0.8320. O resultado será 0.5881 (em radianos). Convertendo 0.5881 radianos para graus, nós obtemos 33.69º, que é exatamente o ângulo em graus entre o cateto adjascente e a hipotenusa na figura acima.

Pronto! Agora que já sabemos o que é cosseno na trigonometria, vamos entender mais sobre a função cos() da Common Lisp e da AutoLISP (a implementação LISP do AutoCAD). Esta função recebe um valor numérico e retorna um valor, também numérico) entre -1 até 1 (ambos inclusos). Veja:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

(format t "Cosseno de 0 = ~F~%" (cos 0))
(format t "Cosseno de 1 = ~F~%" (cos 1))
(format t "Cosseno de 2 = ~F" (cos 2))

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

Cosseno de 0 = 1.0
Cosseno de 1 = 0.5403023
Cosseno de 2 = -0.41614684

Note que calculamos os cossenos dos valores 0, 1 e 2. Observe como os resultados conferem com a curva da função cosseno mostrada abaixo:




Lisp ::: Dicas & Truques ::: Matemática e Estatística

Como calcular MDC em Lisp usando a função GCD

Quantidade de visualizações: 801 vezes
Atualmente a definição de Máximo Divisor Comum (MDC) pode ser assim formalizada:

Sejam a, b e c números inteiros não nulos, dizemos que c é um divisor comum de a e b se c divide a (escrevemos c|a) e c divide b (c|b). Chamaremos D(a,b) o conjunto de todos os divisores comum de a e b.

Podemos calcular o Máximo Divisor Comum na linguagem Common Lisp usando a função GCD. Esta função aceita um número ilimitado de valores inteiros e retorna seu Máximo Divisor Comum.

Veja um trecho de código Common Lisp no qual pedimos para o usuário informar dois números inteiros e, em seguida, fazemos uso da função GCD para retornar o MDC:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; variáveis que vamos usar no programa
(let ((num1)(num2)(mdc))
  ; Vamos ler o primeiro número
  (princ "Informe o primeiro número: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  ; atribui o valor lido à variável num1
  (setq num1 (read))
  
  ; Vamos ler o segundo número
  (princ "Informe o segundo número: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  ; atribui o valor lido à variável num2
  (setq num2 (read))
  
  ; Vamos obter o MDC dos dois números informados
  (setq mdc (gcd num1 num2))
  
  ; E mostramos o resultado
  (format t "O Máximo Divisor Comum é: ~D" mdc)
)

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

Informe o primeiro número: 9
Informe o segundo número: 12
O Máximo Divisor Comum é: 3


Lisp ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como usar o laço loop for da linguagem Lisp

Quantidade de visualizações: 642 vezes
O laço for loop da linguagem Common Lisp é usado quando sabemos exatamente quantas vezes uma instrução ou um grupo de instruções deve ser repetido. Este laço é similar ao laço for encontrado na maioria das linguagens de programação.

Vamos começar vendo um laço for loop que conta de 1 até 10:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; Um laço for loop que conta de 1 até 10
(loop for i from 1 to 10
  do (print i)
)

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

1
2
3
4
5
6
7
8
9
10

Agora veja o mesmo laço usado para contar de 10 até 1, ou seja, em ordem decrescente:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; Um laço for loop que conta de 10 até 1
(loop for i from 10 downto 1
  do (print i)
)

Note que, agora, eu troquei "to" por "downto" para que a variável de controle fosse decrementada, em vez de incrementada. Dessa forma, ao executarmos este código Common Lisp, o resultado será:

10
9
8
7
6
5
4
3
2
1


Lisp ::: Fundamentos da Linguagem ::: Variáveis e Constantes

Como declarar variáveis globais em Lisp usando as funções defvar e defparameter

Quantidade de visualizações: 922 vezes
Em algumas situações nós precisamos declarar variáveis globais em Lisp, ou melhor, em Common Lisp, que é a padronização da Lisp que adotamos para estas dicas.

Variáveis globais em Common Lisp se comportam de forma idêntica àquelas de outras linguagens de programação, ou seja, possuem valores permanentes por todo o sistema Lisp e mantém seus valores até que novos valores são especificados.

Se quisermos, por exemplo, a partir do corpo de uma função acessar uma variável fora dela, então esta variável deverá ser declarada globalmente.

Em Common List nós podemos declarar variáveis globais usando as funções defvar e defparameter. Vamos ver exemplos envolvendo as duas e no final desta dica eu mostro a diferença.

Veja um trecho de código Common Lisp na qual declaramos uma variável global chamada valor e a acessamos de dentro de uma função:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; vamos declarar uma variável global
(defvar valor 10)

; vamos mostrar o valor atual da variável global
(format t "O valor da variável global é ~D" valor)

; agora vamos acessar a variável global
; de dentro de uma função
(defun ModificaValor()
  ; vamos alterar o valor da variável global
  (setq valor 50)
)

; chamamos a função ModificaValor
(ModificaValor)

; e checamos se o valor da variável global foi
; mesmo alterado
(terpri)
(format t "O valor da variável global é ~D" valor)

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

O valor da variável global é 10
O valor da variável global é 50

Veja agora um trecho de código Common Lisp no qual usamos a função defparameter para declarar e inicializar as variáveis globais:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; vamos declarar três variáveis globais
(defparameter *a* 5)
(defparameter *b* 3)
(defparameter *soma* 0)

; agora vamos acessar as variáveis globais
; de dentro de uma função
(defun Somar()
  ; vamos somar as duas variáveis globais
  ; e guardar o resultado em uma terceira
  ; variáveis global
  (setq *soma* (+ *a* *b*))
)

; chamamos a função Somar
(Somar)

; e mostramos o resultado da soma
(format t "A soma das variáveis globais é ~D" *soma*)

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

A soma das variáveis globais é 8

Note que coloquei asteríscos (*) ao redor dos nomes das variáveis globais. Esta é uma prática comum entre programadores Lisp e altamente recomendado pelo comunidade, pois facilita a distinção entre variáveis globais e locais.

Então, qual é a diferença entre defvar e defparameter?

A primeira delas é que a função defparameter nos obriga a informar o valor inicial para a variável global, enquanto a função defvar não o faz.

A segunda diferença é que, ao redefinirmos o valor de uma variável global usando defparameter, o valor armazenado anteriormente será sobreposto, enquanto a função defvar não altera o valor anterior.


Lisp ::: Fundamentos da Linguagem ::: Estruturas de Controle

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

Quantidade de visualizações: 1033 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:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; 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


Lisp ::: Desafios e Lista de Exercícios Resolvidos ::: Lisp Básico

Exercícios Resolvidos de Lisp - Como multiplicar dois números em Lisp - Escreva um programa em Lisp para ler dois números inteiros informados

Quantidade de visualizações: 1687 vezes
Exercício Resolvido de Lisp - Como multiplicar dois números em Lisp - Escreva um programa em Lisp para ler dois números inteiros informados

Pergunta/Tarefa:

Escreva um programa Common Lisp que solicita ao usuário dois números inteiros e mostre a multiplicação dos dois valores, ou seja, o primeiro valor multiplicado pelo segundo.

Sua saída deverá ser parecida com:

Informe o primeiro valor: 3
Informe o segundo valor: 7
3 vezes 7 é 21
Resposta/Solução:

Veja a resolução completa para o exercício em Common Lisp usando o compilador Steel Bank Common Lisp (SBCL), comentada linha a linha:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; Vamos definir as variáveis que vamos
; usar no programa
(defvar n1)
(defvar n2)
(defvar produto)

; Este o programa principal
(defun Multiplicacao()
  ; Vamos ler o primeiro valor
  (princ "Informe o primeiro valor: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  (setq n1 (read))
  ; Vamos ler o segundo valor
  (princ "Informe o segundo valor: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  (setq n2 (read))
  
  ; Agora vamos efetuar a multiplicação dos
  ; dois valores informados
  (setq produto (* n1 n2))
  
  ; E mostramos o resultado
  (format t "~D vezes ~D é ~D" n1 n2
    produto)
)

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



Lisp ::: LISP para Engenharia ::: Geometria Analítica e Álgebra Linear

Como converter Coordenadas Cartesianas para Coordenadas Polares em LISP - LISP para Engenharia

Quantidade de visualizações: 647 vezes
Nesta nossa série de LISP e AutoLISP 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 LISP completo que recebe as coordenadas cartesianas (x, y) e retorna as coordenadas polares (r, __$\theta__$):

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

; programa LISP que converte Coordenadas Cartesianas
; em Coordenadas Polares
(let((x)(y)(raio)(theta)(angulo_graus))
  ; vamos ler as coordenadas cartesianas
  (princ "Valor de x: ")
  (force-output)
  (setq x (read))
  (princ "Valor de y: ")
  (force-output)
  (setq y (read))
  
  ; vamos calcular o raio
  (setq raio (sqrt (+ (expt x 2) (expt y 2))))
  
  ; agora calculamos o theta (ângulo) em radianos 
  (setq theta (atan y x))

  ; queremos o ângulo em graus também
  (setq angulo_graus (* 180 (/ theta pi)))
  
  ; e exibimos o resultado
  (princ "As Coordenadas Polares são: ")
  (format t "raio = ~F, theta = ~F, ângulo em graus: ~F"
    raio theta angulo_graus)
)

Ao executar este código LISP 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.


Veja mais Dicas e truques de Lisp

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



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