Tipo de argumentos. valor. argumentos

Transcrição

1 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

2 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.

3 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

4 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.

5 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

6 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)

7 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.

8 Operadores Lógicos Expressões lógica com And: (and expr1 expr2... exprn)

9 Operadores Lógicos Expressões lógica com And: (and (< 2 5) (< 2 4)) =>#t

10 Operadores Lógicos Expressões lógica com Or: (or expr1 expr2... exprn)

11 Operadores Lógicos Expressões lógica com Or: (or (< 2 5) (< 2 4)) =>#t

12 Operadores Lógicos Expressões lógica com Not: (not expr)

13 Operadores Lógicos Expressões lógica com Not: (not (< 5 10)) => #f

14 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.

15 Expressões Condicionais Expressão condicional If : (if condição consequência alternativa) (if condição consequência)

16 Expressões Condicionais Expressão condicional If : (if (< a b) (square a) (square b)) (if(<x1x2)(>x2x3) (if (> x1 x2) (< x2 x3) #f))

17 Expressões Condicionais Expressão condicional Cond : (cond (condição1 consequência1) (condição2 consequência2)... (else alternativa))

18 Expressões Condicionais Expressão condicional Cond : (cond ((> a b) (square a)) ((> b c) (square b))... (else (square c)))

19 Expressões Condicionais Expressão condicional Case : (case arg expr1 expr2 expr3...)

20 Expressões Condicionais Expressão condicional Case : (case (+ 3 4) ((7) Sete) ((2) Dois) (else Nada)) => Sete

21 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?

22 Por exemplo, (string? "Laboratório de informática I") #t (number? 10) #t (boolean? #f) #t (string? 10) #f

23 Além desses predicados, há outros que testam subconjuntos desses tipos: (positive? -1) #f (integer? -2) #t (rational? 2/3) #t

24 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)

25 Utilizamos o processo de nomeação para associarmos um nome a uma determinada expressão

26 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))

27 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

28 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.

29 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.

30 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)

31 (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==============")

32 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.

33 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.

34 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)))))

35 (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))))))))

36 (* 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

37 Recursão interativa Recursão em arvore Sequenciação

38 Declarações Utilizamos a palavra reservada set! Para alterar variáveis: (define f 10) f (set! f 6) f O resultado será 10 6

39 Declarações Utilizando a palavra reservada let. Utilizando a palavra reservada let*. Utilizando a palavra reservada letrec.