Operação Numero de argumentos Tipo de argumentos valor (+ <e1> <en>) 2 ou + Numérico Soma ( <e1> <en>) 2 ou + Numérico Subtração ( <e>) 1 Numérico Simétrico (/ <e1>...<en>) 2 ou + Numérico Divisão (cos <e>) 1 Numérico Cosseno (sin <e>) 1 Numérico Seno (log <e>) 1 Numérico Logaritmo natural (sqrt <e>) 1 Numérico Raiz quadrada (max <e1> <en>) 1 ou + Numérico Máximo (min <e1> <en>) 1 ou + Numérico Mínimo (quotient <e1> <e2>) 2 Numérico Parte inteira da divisão (remainder <e1> <e2>) 2 Numérico Resto da divisão (truncate <e>) 1 Numérico Parte inteira não superior a expressão (inexact >exact <e>) 1 Numérico Inverso do numero decimal para fracionário
Predicados e condições Uma operação que produz resultado do tipo logico chama-se predicado. Uma expressão cujo valor é do tipo logico chama-se condição.
Predicado Nº de Argumentos Tipo de Valor argumentos (odd? <e>) 1 Inteiro #t se <e> for ímpar (even? <e>) 1 Inteiro #t se <e> for par (= <e1> <en>) 2 ou + Numérico #t se e só se as expressões forem iguais (> <e1> <en>) 2 ou + Numérico #t se e só se as expressões forem em ordem decrescente e diferentes (< <e1> <en>) 2 ou + Numérico #t se e só se as expressões forem em ordem crescente e diferentes (>= <e1> <en>) 2 ou + Numérico #t se e só se as expressões forem em ordem decrescente e podendo existir iguais (<= <e1> <en>) 2 ou + Numérico #t se e só se as expressões forem em ordem decrescente e podendo existir iguais
Avaliação de expressões Para avaliar expressões, o interpretador do Scheme utiliza regras de avaliação. Podemos considerar que existe uma regra de avaliação constituída pelas seguintes: 1.Se a expressão é uma constante, o seu valor é a própria constante.
1.Se a expressão é uma operação primitiva, o seu valor é o procedimento interno associado a essa operação. 2.Se a expressão é uma combinação, o seu valor é calculadodoseguintemodo: a)avaliam-se as subexpressões na combinação
a.aplica-se o procedimento que é o valor da primeira subexpressão (o operador) aos argumentos que correspondem aos valores das restantes subexpressões (os operandos)
Operadores Lógicos Existem três tipos de expressões lógicas: Usando a palavra reservada And. Usando a palavra reservada Or. Usando a palavra reservada Not.
Operadores Lógicos Expressões lógica com And: (and expr1 expr2... exprn)
Operadores Lógicos Expressões lógica com And: (and (< 2 5) (< 2 4)) =>#t
Operadores Lógicos Expressões lógica com Or: (or expr1 expr2... exprn)
Operadores Lógicos Expressões lógica com Or: (or (< 2 5) (< 2 4)) =>#t
Operadores Lógicos Expressões lógica com Not: (not expr)
Operadores Lógicos Expressões lógica com Not: (not (< 5 10)) => #f
Expressões Condicionais Existem três tipos de expressões condicionais: Usando a palavra reservada If. Usando a palavra reservada Cond. Usando a palavra reservada Case.
Expressões Condicionais Expressão condicional If : (if condição consequência alternativa) (if condição consequência)
Expressões Condicionais Expressão condicional If : (if (< a b) (square a) (square b)) (if(<x1x2)(>x2x3) (if (> x1 x2) (< x2 x3) #f))
Expressões Condicionais Expressão condicional Cond : (cond (condição1 consequência1) (condição2 consequência2)... (else alternativa))
Expressões Condicionais Expressão condicional Cond : (cond ((> a b) (square a)) ((> b c) (square b))... (else (square c)))
Expressões Condicionais Expressão condicional Case : (case arg expr1 expr2 expr3...)
Expressões Condicionais Expressão condicional Case : (case (+ 3 4) ((7) Sete) ((2) Dois) (else Nada)) => Sete
O padrão Scheme define que cada objecto deve ser de exactamente um destes tipos, e há procedimentos que verificam os tipos desses objectos: boolean? bytevector? char? eof-object? null? number? pair? port? procedure? string? symbol? vector?
Por exemplo, (string? "Laboratório de informática I") #t (number? 10) #t (boolean? #f) #t (string? 10) #f
Além desses predicados, há outros que testam subconjuntos desses tipos: (positive? -1) #f (integer? -2) #t (rational? 2/3) #t
Nomes A operação de nomeação realiza-se usando o procedimento primitivo Define Um Define é definido seguido do nome do procedimento e de seus argumentos. O corpo do programa é que dita a forma como o procedimento será avaliado. A forma geral de um Define pode ser expressa da seguinte forma: (define (nome arg1 arg2 arg3...) corpo)
Utilizamos o processo de nomeação para associarmos um nome a uma determinada expressão
Definindo Funções Uma segunda forma de abstração, bem mais poderosa que o uso de nomes, é a definição de funções. Em matemática, escrevemos f(x) = 2x para definir uma função f que leva um número ao seu dobro. Em Scheme, essa função seria definida como: (define f (lambda (x) (* 2 x))) Genericamente temos: (define nome do procedimento (lambda (parâmetro 1 parâmetro 2...) corpo do procedimento))
A construção lambda usada acima serve exactamente para criarmos funções. O construtor lambda actua sobre uma lista com os parâmetros da função e um corpo que calcula o valor da função. No nosso exemplo, o único parâmetro é x, e o corpo é a expressão (* 2 x). O define é usado para dar um nome à função criada com o lambda. Funções podem ter zero, um, ou mais parâmetros
Conforme explicado acima, o define e o lambda tem significados independentes, e são muitas vezes usados separadamente. O lambda cria funções, enquanto o define nomeia valores que, em particular, podem ter sido criados por uma expressão lambda. Por outro lado, é extremamente comum usarmos a combinação.
Input e Output Muitos programas, em Scheme, evitam-se operações de entrada e saída explícitas, obtendo entrada através de chamadas de função diretas na janela de interações e produzindo saída retornando valores. Outros programas explicitamente imprimir saída para o usuário durante a avaliação usando write ou display, ou explicitamente solicitar entrada do usuário usando Read ou Read-Char.
A entrada e saída explícitas aparecem na janela de interações, mas dentro de caixas especiais que separam i/o explícitos de expressões e resultados normais. Por exemplo, a avaliação > read na janela interações produz uma caixa especial para inserir entrada. (define v (read)) (display v) (newline)
(display "===COMPARAÇÃO DE 2 NÚMEROS DIFERENTES===") (newline) (display "Informe o 1o número ") (define num1 (read)) (display "Informe o número 2o numero ") (define num2 (read)) (if (> num1 num2) (string-append "O primeiro número, " (number->string num1) ", é o maior ") (string-append "O segundo número, " (number->string num2) ", é o maior") ) (display "===============Fim==============")
Procedimentos gerados por procedimentos Recursão São procedimentos que se chamam a si próprios. O exemplo que tipicamente se apresenta para ilustrar o conceito da recursividade é a função potenciação e factorial. É recorrendo à Recursividade que o Scheme implementa as tarefas repetitivas, já que não possui, pelo menos à partida, estruturas de repetição (for, while, e outras), como existem noutras linguagens de programação.
A Recursividade faz parte do nosso quotidiano, tão naturalmente, que quase não damos por ela. Se se pretende subir umas escadas, toma-se sem pensar, as seguintes acções: Ao atingir o cimo das escadas, a tarefa de as subir está terminada; Enquanto o cimo não for atingido Avançar um degrau e retomar a tarefa de subir as escadas, mas agora, tendo já avançado um dos degraus, a dimensão do problema aparece mais reduzida.
Procedimentos gerados por procedimentos Recursão Linear Aqueles que geram processos que apresentam um padrão de evolução. Ex: (define (potencia x n) ( if(= n 1) x (* x (potencia x (- n 1)))))
(define (potencia x n) ( if(= n 1) x (* x (potencia x ( n 1))))) (potencia 2 8) (* 2 (potencia 2 7)) (* 2 (* 2 (potencia 2 6))) (* 2 (* 2 (* 2 (potencia 2 5))) (* 2 (* 2 (* 2 (* 2 (potencia 2 4)))) (* 2 (* 2 (* 2 (* 2 (* 2 (potencia 2 3))))) (* 2 (* 2 (* 2 (* 2 (* 2 (* 2 (potencia 2 2))))))) (* 2 (* 2 (* 2 (* 2 (* 2 (* 2 (* 2 (potencia 2 1))))))))
(* 2 (* 2 (* 2 (* 2 (* 2 (* 2 (* 2(* 2 1)))))))) (* 2 (* 2 (* 2 (* 2 (* 2 (* 2 (* 2 2))))))) (* 2 (* 2 (* 2 (* 2 (* 2 (* 2 4))))))) (* 2 (* 2 (* 2 (* 2 (* 2 8))))))) (* 2 (* 2 (* 2 (* 2 16)))))) (* 2 (* 2 (* 2 32))) (* 2 (* 2 64)) (* 2 128) 256
Recursão interativa Recursão em arvore Sequenciação
Declarações Utilizamos a palavra reservada set! Para alterar variáveis: (define f 10) f (set! f 6) f O resultado será 10 6
Declarações Utilizando a palavra reservada let. Utilizando a palavra reservada let*. Utilizando a palavra reservada letrec.