Curso Livre de Algoritmos e Programação/Guile: Operadores Lógicos, Relacionais e Aritméticos

Guile: Operadores Lógicos, Relacionais e Aritméticos

·       Operadores lógicos

Os operadores lógicos para guile lembram os operados da python também, pois também são os 3, “and”, “or” e “not”. Quando a expressão é verdadeira é #t, já quando ela é falsa é #f quando é diferente de verdadeira.

·        Operadores relacionais

Os operadores relacionais também são parecidas com os operadores em python, estes são “==”, “<”, “>”, <=, >=, podem ser utilizadas da seguinte forma (> 5 3) ; => #t.

Em guile também existe o “eqv?” que observa se os caracteres são equivalentes.

·        Operadores aritméticos

Os operadores aritméticos em guile são “+” que é o operador de soma, “-“ de subtração, “*” de multiplicação, “/” de divisão, “expt” que é o operador de exponencial, “quotient” que pega a parte inteira de divisão e “remainder” que pega o resto da divisão

Operadores Lógicos, Relacionais e Aritméticos

Lógicos

#t ; para verdadeiro

#f ; para falso -- diferente de #f é verdadeiro

(not #t) ; => #f

(and 0 #f) ; => #f

(or #f 0)  ; => 0

Relacionais

Números

(> 2 2) ; ==, <, >, <==, >=

(= 3 3.0) ; => #t

(eqv? 3 3)     ; => #t

Caracteres

(char=? #\c #\c) ; => #t

(eqv? #\c #\c) ; => #t

Objetos

(eq? (list 3) (list 3)) ; => #f (ponteiros diferentes)

(eq? 'a 'a) ; => #t (símbolos comparados aos ponteiros)

(eqv? 'a 'a)   ; => #t

(equal? (list 'a 'b) (list 'a 'b)) ; => #t

(equal? (list 'a 'b) (list 'b 'a)) ; => #f

Aritméticos

(+ 1 1)  ; => 2

(- 8 1)  ; => 7

(* 10 2) ; => 20

(expt 2 3) ; => 8

(quotient 5 2) ; => 2

(remainder 5 2) ; => 1

(/ 35 5) ; => 7

Estruturas de Seleção e Estruturas de Repetição

Seleção

(if #t                  ; teste

    "aqui é verdadeiro" ; então

    "aqui é falso")     ; senão

; => "aqui é verdadeiro"

(cond ((> 2 2) (error "errado!"))

      ((< 2 2) (error "errado de novo!"))

      (else 'ok)) ; => 'ok

Repetição

Recursão

(define (fact n)

  (if (= n 1)

      1

      (* n (fact (- n 1)))))

Cauda Recursiva

(define (lp i)

  (when (< i 10)

    (format #t "i=~a\n" i)

    (lp (1+ i))))

(lp 5) ; => i=5, i=6, ...

Chamado Let

(let lp ((i 0))

  (when (< i 10)
    (format #t "i=~a\n" i)

    (lp (1+ i)))) ; => i=0, i=1, ...

Iteração

(for-each (lambda (i) (format #t "i=~a\n" i))

          (iota 10)) ; => i=0, i=1, ...

Expressão do

(do vínculos (predicado valor)

corpo)

[vínculos] → ((p1 i1 u1) (p2 i2 u2) … )

variável p, inicialização i, atualização de ciclo u

(define (fact-do n)

  (do ((n1 n (- n1 1)) (p n (* p (- n1 1)))) ((= n1 1) p)))

Vetores

'#(1 2 3)  ; vetor de inteiros

'#(a 0 #\a); símbolo, inteiro, caractere

(define vec (vector 2 2 3 4))

(define wall (make-vector 100 'bottle-of-beer))

;; Use vector-set! para atualizar um slot

(vector-set! vec 0 1)

(vector-set! wall 99 'down)

vec ; => #(1 2 3 4)

Funções

Simples

; Olá mundo como uma variável

(define vhello "Olá mundo")     ;1

; Olá mundo como uma função

(define fhello (lambda ()         ;2

         "Olá mundo"))

Com parâmetros

; olá com nome

(define hello

  (lambda (nome)

    (string-append "Olá " nome "!")))

; soma de três números

(define sum3

  (lambda (a b c)

    (+ a b c)))

Forma curta

; olá com nome

(define (hello nome)

  (string-append "Olá " nome "!"))

; soma de três números

(define (sum3 a b c)

  (+ a b c))

Referencias

Scheme (introdução) - https://rodrigorgs.github.io/aulas/mata56/aula08-lisp