PortugolViana Versão 0.3b
Manual da Linguagem
Projecto desenvolvido por: Nélson Cerqueira Octávio Gradíssimo Coordenador: António Miguel Cruz
PORTUGOLVIANA
Manual da Linguagem
PORTUGOLVIANA
Manual da Linguagem
Índice: Projecto PortugolViana PortugolViana .......................................... ................................................................ ............................................ .................................... .............. 0 Equipa de desenvolvimento desenvolvimento do PortugolViana: PortugolViana: ............................................. ....................................................... .......... 0 Introdução............................................ ................................................................... ............................................. ............................................ ................................ .......... 1 1.1. Linguagem Algorítmica Algorítmica......................................... ................................................................ ............................................ ..................... 1 1.2. Comentários.......................................... ................................................................. ............................................. ...................................... ................ 2 2.
Identificadores Identificadores ............................................. ................................................................... ............................................ ....................................... ................. 3 2.1. Regras Utilizadas na Construção de Identificadores Identificadores ......................................... ......................................... 3 2.2. Variáveis ............................... ...................................................... ............................................. ............................................ ................................ .......... 5 2.3. Constantes........................................... .................................................................. ............................................. ........................................ .................. 6
3.
Tipos de Dados ...................................... ............................................................ ............................................. ............................................. ...................... 7 3.1. Tipos de Dados Primários .................................................. ........................................................................ ............................... ......... 7 3.2. Tipos de Dados Estruturados........................................... .................................................................. .................................. ........... 8 3.2.1. Tipo / Estrutura........................................... ................................................................ ........................................... ............................... ......... 8 3.2.2. Renomeação de tipos de dados primitivos: ............................ .................................................... ........................ 8 3.2.3. Agrupar dados de diferentes tipos: ....................... .............................................. .......................................... ................... 9 3.3. Arrays ........................................... ................................................................. ............................................ ............................................ ........................ 10 3.4. Listas Ligadas ......................... ................................................ ............................................. ............................................ ............................ ...... 12 3.5. Listas Duplamente Ligadas ................................................. ........................................................................ ............................ ..... 14
4.
Operadores............................................................ ................................................................................... ............................................. ........................... ..... 16 4.1. Aritméticos Aritméticos ............................................. .................................................................... ............................................... .................................. .......... 16 4.1.1. Operadores disponíveis disponíveis para números inteiros ............................................. ............................................. 16 4.1.2. Operadores disponíveis disponíveis para números reais: ................................... ................................................ ............. 17 4.2. Lógicos ........................................................... .................................................................................. ............................................. .......................... .... 18 4.3. Relacionais Relacionais .......................................... ................................................................ ............................................. ...................................... ............... 20 4.4. Texto ........................................ ............................................................. ........................................... ............................................ ............................. ....... 21 4.5. Prioridade de Operadores ........................................ .............................................................. ........................................ .................. 22
5.
Entrada / Saída............................................ .................................................................. ............................................ ...................................... ................ 23 5.1. Ler................................. ....................................................... ............................................ ............................................. ....................................... ................ 23 5.2. Escrever ......................................................... ............................................................................... ............................................. ............................ ..... 24
6.
Selecção.............................................. ..................................................................... .............................................. ............................................. ...................... 25 6.1. Se .......................................... ................................................................ ............................................ ............................................. ............................... ........ 25 6.2. Escolhe ............................................ ................................................................... ............................................. ......................................... ................... 27
7.
Repetição ............................................ .................................................................. ............................................ ............................................. ......................... 29 7.1. Enquanto ................................ ...................................................... ............................................ ............................................. .............................. ....... 29 7.2. Repete .................................................. ......................................................................... ............................................. ..................................... ............... 31 ii
PORTUGOLVIANA
Manual da Linguagem
7.3. Para .................................................................................................................. 33 7.4. Faz ................................................................................................................... 35 8.
Funções................................................................................................................... 36 8.1. Funções Pré-Definidas..................................................................................... 36 8.1.1. ABS .............................................................................................................. 36 8.1.2. ALEATORIO ............................................................................................... 37 8.1.3. ARRED: ....................................................................................................... 38 8.1.4. EXP............................................................................................................... 39 8.1.5. FRAC ............................................................................................................ 40 8.1.6. INT ............................................................................................................... 41 8.1.7. LN ................................................................................................................. 42 8.1.8. LOG .............................................................................................................. 43 8.1.9. POTENCIA .................................................................................................. 44 8.1.10. Raiz ............................................................................................................. 45 8.1.11. ACOS ......................................................................................................... 46 8.1.12. ACTG ......................................................................................................... 47 8.1.13. ASEN .......................................................................................................... 48 8.1.14. ATAN ......................................................................................................... 49 8.1.15. COS ............................................................................................................ 50 8.1.16. COSH ......................................................................................................... 51 8.1.17. CTG ............................................................................................................ 52 8.1.18. CTGH ......................................................................................................... 53 8.1.19. SEN............................................................................................................. 54 8.1.20. SENH .......................................................................................................... 55 8.1.21. TAN ............................................................................................................ 56 8.1.22. TANH ......................................................................................................... 57 8.2. Definição ......................................................................................................... 58 8.2.1. Definição de Funções ................................................................................... 58 8.2.2. Parâmetros e Argumentos............................................................................. 60 8.2.3. Passagem por Valor ...................................................................................... 60 8.2.4. Passagem por Referência.............................................................................. 62
9.
Referências Bibliográficas...................................................................................... 64
iii
PORTUGOLVIANA
Manual da Linguagem
Projecto PortugolViana PortugolViana é uma ferramenta open-source para edição e execução de algoritmos escritos na linguagem Portugol. A ferramenta PortugolViana está a ser desenvolvida na Escola Superior de Tecnologia e Gestão, do Instituto Politécnico de Viana do Castelo, no âmbito de um projecto para melhoria do processo de ensino-aprendizagem em disciplinas introdutórias de algoritmia e programação. O desenvolvimento do PortugolViana partiu do código de uma outra ferramenta opensource, para execução de algoritmos Portugol, desenvolvida no Instituto Politécnico de Tomar, denominada simplesmente Portugol. A versão 0.3b do PortugolViana, corresponde a um branch na evolução da ferramenta Portugol do I.P. Tomar, e expande a linguagem Portugol “clássico” com Funções, Passagem de parâmetros por valor ou por referência, Estruturas, Listas ligadas, Stacks e Queues. Esta expansão do Portugol não envolve qualquer mudança no paradigma de desenvolvimento de algoritmos, constituindo sim uma evolução natural do Portugol que vai de encontro aos conceitos e construtores existentes na maioria das linguagens de programação que, adicionalmente ao objectivo principal de desenvolvimento do raciocínio algorítmico, é o que se pretende ensinar nas disciplinas atrás referidas. Foi, também, melhorada a interface com o utilizador de modo a possibilitar, já na próxima versão (prevista para Fev. 2008), a animação de estruturas complexas (arrays, listas ligadas, stacks e queues). Para além disso, foi elaborado um manual da linguagem Portugol, que engloba o Portugol “clássico”, assim como as novas features do PortugolViana. Este manual pode ser consultado on-line, na ajuda da ferramenta, ou como PDF. Equipa de desenvolvimento do PortugolViana: Nelson Cerqueira - Desenvolvimento de novas funcionalidades e expansão da linguagem Octávio Gradíssimo - Site do Projecto, Manuais de Utilizador (linguagem PortugolViana e ferramenta PortugolViana) António Miguel Cruz - Coordenação do Projecto
PORTUGOLVIANA
Manual da Linguagem
Introdução 1.1. Linguagem Algorítmica A linguagem algorítmica utiliza o português para a definição dos comandos e tem as seguintes características: 1 - A linguagem não é sensível à capitulação (não faz distinção entre letras minúsculas e maiúsculas). 2 - Todos os algoritmos começam por inicio e terminam com fim. 3 - Cada linha contém apenas um comando (o enter funciona como sinalizador de fim de comando). 4 - O sinal de atribuição é a seta (
<-
).
5 - A definição de símbolos é feita em qualquer local do algoritmo. Sintaxe: 1:Listagem de Tipos/Estruturas 2: 3:Listagem de Funções 4: 5:inicio 6: Algoritmo 7:fim
Neste manual todos os exemplos de código apresentados terão as características anteriores: •
•
Todas as linhas são apresentadas precedidas pelo seu número de ordem, na aplicação esta apresentação não é válida, uma vez que cada linha começa com a instrução (todas as linhas que não sejam precedidas do seu número de ordem são continuação da instrução anterior). Este tipo de apresentação apenas serve para que as linhas de código sejam identificadas mais rapidamente.
1
PORTUGOLVIANA
Manual da Linguagem
1.2. Comentários Quando um algoritmo executa tarefas complexas, ou simplesmente quando o programador quer chamar a atenção para um determinado bloco ou linha de código, existe a possibilidade de inserir comentários. Aquando da execução do algoritmo, os comentários são, simplesmente, ignorados pelo editor do PortugolViana. Os comentários podem ser introduzidos em qualquer parte do algoritmo. Para o fazer o utilizador dispõe de duas opções: Comentar uma linha de código: Para comentar uma linha inserem-se os caracteres // antes do comentário. 1:inicio // comentário inserido no final de uma linha 2: ... //[instrução] instrução comentada (não será executada) 3: 4: ... // linha de comentário 5: 6: ... 7: [instruções] 8: ... 9:fim
Comentar um bloco de código: Para comentar um bloco de código inserem-se os caracteres /* antes do comentário e os caracteres */ no final do mesmo. /*
Desta forma pode, por exemplo, incluir uma breve descrição do algoritmo antes da implementação do mesmo. */
1:inicio 2: ... /* 3: 4: [instruções] instruções comentadas (não serão executadas) */ 5: 6: ... 7: [instruções] 8: ... 9:fim
2
PORTUGOLVIANA
Manual da Linguagem
2. Identificadores 2.1. Regras Utilizadas na Construção de Identificadores Os dados num programa podem ser utilizados sob a forma de constantes ou variáveis. Em programação, as constantes podem ser escritas sob a forma de dados directos ou identificadores. As variáveis, por sua vez, são sempre associadas a identificadores. Definição: Identificadores são nomes que se atribuem a variáveis, constantes ou outros elementos com que se opera dentro de um programa (Arrays, Funções, ...). É considerada boa prática de programação o uso de identificadores que correspondam aos dados que pretendem armazenar, (Ex: Telf - para armazenar o número de telefone). Regras: •
•
•
•
O primeiro caracter é sempre uma letra: o 2nome (não é um identificador válido); o nome (identificador válido). Não existem espaços em branco nem acentos: o salário real (incorrecto); o salarioreal (correcto); o salario_real (correcto). Apenas os últimos caracteres poderão ser algarismos: o X3Y (incorrecto); o nome2 (correcto); o telefone34 (correcto). As palavras reservadas da linguagem não servem para identificadores: o Palavras reservadas do PortugolViana:
ABS
ACOS
ACTG
ALEATORIO
ARRED
ASEN
ATAN
ATE
CARACTER
COMPRIMENTO
CONSTANTE
COS
COSH
CTG
CTGH
DE
ENQUANTO
ENTAO
ESCREVER
ESTRUTURA
EXP
FALSO
FAZ
FIM
FIMENQUANTO
FIMFUNCAO
FIMSE
FRAC
FUNCAO
INICIO
INT
INTEIRO
LER
LETRA
LN
LOG
LOGICO
PARA
PASSO
POTENCIA
PROXIMO
RAIZ
REAL
REPETE
RETORNAR
SE
SEN
SENAO
SENH
TAN
TANH
TEXTO
TIPO
VERDADEIRO
•
Caracteres que não contêm letras e algarismos não são válidos ( +, -, *, /, %, &, !, ...). 3
PORTUGOLVIANA
Manual da Linguagem
•
Caracteres compostos como ç, ã, é, ... são igualmente inválidos.
•
Símbolos permitidos:
A B C D E F G H I J K L M N O P Q R S T U V X Y W Z a b c d e f g h i j k l m n o p q r s t u v x y w z _ 0 1 2 3 4 5 6 7 8 9
As variáveis e as constantes pertencentes a um programa estão sujeitas às operações possíveis de acordo com o tipo de dados que representam e do objectivo para o qual se constrói o programa. Constituem-se assim as expressões, que não são mais do que conjuntos de variáveis, constantes e operadores, passíveis de tratamento computadorizado.
4
PORTUGOLVIANA
Manual da Linguagem
2.2. Variáveis Sintaxe: variavel [tipo] [nome] <- [expressão] variavel [tipo] [nome] <- [valor] ,[nome] <- [expressão] [tipo] [nome] <- [expressão] [tipo] [nome]
Definição: Define um símbolo cujo valor pode ser alterado durante o seu ciclo de vida. As variáveis são o elemento básico de processamento. A sua declaração permite definir que tipo de informação irá conter. A declaração de variáveis segue as seguintes regras: 1 - O nome tem obedecer às regras descritas no capítulo regras. 2 - O valor de inicialização tem de ser compatível com tipo de variável definido. 3 - Se o valor de inicialização for omitido a variável é inicializada com os valores por defeito. 4 - É possível definir mais que uma variável utilizando o caracter virgula (,) 5 - É possível omitir a palavra variável. Exemplos: 1:variavel inteiro idade <- 18 2:variavel real peso <- 23.14 3:logico repetente 4:texto nome <- "Antonio" , apelido <- "Sousa" 5:caracter sexo
5
PORTUGOLVIANA
Manual da Linguagem
2.3. Constantes Sintaxe: constante [tipo] [nome] <- [valor] constante [tipo] [nome] <- [expressão] constante [tipo] [nome] <- [valor] ,[nome] <- [expressão]
Definição: Define um símbolo cujo valor permanece inalterável durante o seu ciclo de vida. Segue as mesmas regras que a definição de variáveis excepto que não é possível omitir o valor de inicialização Exemplos: 1:constante inteiro meses <- 12 2:constante real pi <- 3.14
6
PORTUGOLVIANA
Manual da Linguagem
3. Tipos de Dados 3.1. Tipos de Dados Primários Os dados são a base da informação, constituindo termos genéricos para informações destinadas ou passíveis de serem tratadas pelo computador. Os dados são classificados quanto ao tipo ou natureza da informação de que são base. Consideram-se os seguintes tipos de dados primários ou simples: Tipo
Descrição
Valores
Valor por defeito
Inteiro
Valores ordinais definidos com quatro bits
-2 147 483 648 2 147 483 647
0
Real
Valores com parte decimal definidos com 64 bits
-1.7 E 308 1.7 E 308
0.0
Logico
Valores lógicos - 1 bit
Caracter
Caracteres da Tabela ASCII
Texto
Conjuntos de caracteres
verdadeiro falso ASCII(0) ASCII(255) "Sequências de caracteres" "entre aspas"
falso " " (espaço) "" (vazio)
7
PORTUGOLVIANA
Manual da Linguagem
3.2. Tipos de Dados Estruturados 3.2.1. Tipo / Estrutura Estruturas - são um tipo de dados estruturados que permitem agrupar dados de tipos diferentes denominados de campos, o acesso a cada um dos campos não é feito através da sua localização na estrutura, mas sim através do nome do campo a que se pretende aceder. As estruturas podem ser usadas de para dois fins: • •
Renomeação de tipos de dados primitivos; Agrupar dados de diferentes tipos.
3.2.2. Renomeação de tipos de dados primitivos: Sintaxe: A renomeação de tipos de dados primitivos terá de ser feita em primeiro lugar, isto é, será efectuada antes do algoritmo principal e antes da definição de funções (caso existam). 1:tipo novo_tipo 2: 3:inicio 4: variavel novo_tipo 5: ... 6: [instruções] 7: ... 8:fim
Depois de ter sido efectuada a renomeação do tipo de dados primitivo, o novo tipo de dados assume o mesmo comportamento que o anterior, sendo possível efectuar todas as operações que são permitidas para o tipo de dados primitivo. Exemplo: 1:tipo inteiro novo_tipo 2: 3:inicio 4: variavel novo_tipo f2 5: f2 <- 3 6: escrever f2 7:fim
Ver o exemplo: tipo_primitivo.alg Resultado: 3
Como pode verificar, a variável f2, do tipo novo_tipo, tem um comportamento idêntico a uma variável do tipo inteiro. 8
PORTUGOLVIANA
Manual da Linguagem
3.2.3. Agrupar dados de diferentes tipos: Sintaxe: Tal como a renomeação de tipos de dados primitivos, a definição de uma estrutura complexa terá de ser feita em primeiro lugar, isto é, será efectuada antes do algoritmo principal e antes da definição de funções (caso existam). 1:tipo estrutura 2:inicio 3: ... 4: 5: ... 6:fim estrutura 7: 8:inicio 9: variavel 10: . <- 11: ... 12: . <- 13: ... 14:fim
A referência a cada um dos campos da estrutura é feita da forma explicada anteriormente: . . Tal como na renomeação de tipos primitivos, cada um dos campos admite as operações correspondentes ao seu tipo de dados. Exemplo: 1:tipo estrutura ident 2:inicio 3: texto nome 4: real versao 5: texto distrib 6:fim estrutura 7:inicio 8: variavel ident f 9: f.nome <- "PortugolViana" 10: f.versao <- 3 11: f.distrib <- " Beta" 12: escrever "Está a utilizar: \n" 13: escrever f.nome,"\t Versão: ",f.versao,f.distrib 14:fim
Ver o exemplo: tipo_estrutura.alg Resultado: Está a utilizar: PortugolViana Versão: 3.0 Beta
Como pode verificar, desta forma, é possível agrupar dados do tipo texto e numéricos numa só estrutura de dados. 9
PORTUGOLVIANA
Manual da Linguagem
3.3. Arrays Sintaxe: nome [dimensão] nome[dimensão] nome[dimensão] <- {valor_1, . . . , valor_n}
Descrição: Define um conjunto de dados todos do mesmo tipo que podem ser acedidos através de um índice. Representação gráfica: Para uma melhor percepção do conceito de array, considera-se a seguinte representação gráfica: Array A = Índice: 0
1
2
3
4
… …
n
A cada uma das caixas corresponde um índice (inteiro de base 0), assim: Array A = 1
4
8
Índice:
1
2
0
10 2 3
4
O array A tem 5 posições (A[5]), sendo cada uma delas referenciada como A[nº do índice] (A[2]=8, por exemplo).
Regras: 1 - Se a declaração omitir o termo o array é variavel. 2 - A definição do nome obedece às mesmas regras que qualquer identificador. 3 - A dimensão tem de ser um valor inteiro ou uma expressão com resultado inteiro. 4 - As dimensões estão contidas dentro de parênteses rectos. 5 - São permitidas tantas dimensões, quantas as desejadas. 6 - Se o valor de inicialização for omitido todo o conjunto é inicializado com os valores por defeito. 7 - A inicialização é feita com os dados compreendidos entre chavetas e separados por vírgulas. 8 - Se o número de valores for insuficiente os restantes elementos são inicializados com os valores por defeito.
10
PORTUGOLVIANA
Manual da Linguagem
Exemplo: 1:constante texto estacoes[4] <- {"inverno", "outono", "primavera" , "verão" } 2:variavel inteiro notas[3] <- {10,20} 3:real salarios[12] 4:logico bits[8]
11
PORTUGOLVIANA
Manual da Linguagem
3.4. Listas Ligadas São estruturas formadas por um conjunto de dados de forma a preservar a relação de ordem linear entre eles. Uma lista é composta por nós, os quais podem conter, cada um deles, um dado primitivo ou composto. Além dos dados, esta estrutura de dados armazena a referência para o elemento seguinte na lista. A vantagem de uma lista sobre um array ocorre quando é necessário inserir ou eliminar um elemento no meio de um grupo de outros elementos. Por exemplo, vamos supor que precisemos inserir um elemento x entre o terceiro e quarto elementos num array de tamanho 10, que contém actualmente sete itens (x[0] a x[6]). Os itens 6 a 3 precisam primeiro ser deslocados de uma casa e o novo elemento precisa ser inserido na posição 3 agora disponível. Se o array contivesse 500 ou 1.000 elementos, um número correspondentemente maior de elementos precisaria ser deslocado. De modo semelhante, para eliminar um elemento de um array sem deixar um intervalo, todos os elementos posteriores ao elemento eliminado precisariam ser deslocados uma posição. Para permitir a utilização de listas, o PortugolViana tem pré-definido um tipo de dados chamado lista_ligada. Neste tipo de dados está implícito um elemento essencial à utilização de listas: •
Seguinte - para referenciar o elemento seguinte ao corrente.
Além destes dois elementos, existe ainda a função novo_no, que permite criar um novo nó na lista em questão. Sintaxe: 1:tipo estrutura 2:inicio 3: ... 4: 5: ... 6:fim estrutura 7: 8:inicio 9: lista_ligada 10: <- novo_no 11: . <- 12: .seguinte <- 13: ... 14:fim
12
PORTUGOLVIANA
Manual da Linguagem
Representação gráfica: Para uma melhor percepção do conceito de lista ligada, considera-se a seguinte representação gráfica: Lista Ligada:
Elemento
Seguinte
Elemento
Seguinte
…
Exemplo: 1:tipo estrutura novo_tipo 2:inicio 3: texto u 4:fim estrutura 5: 6:inicio 7: lista_ligada novo_tipo t 8: t <- novo_no(novo_tipo) 9: t.u <- "Olá" 10: t.seguinte <- novo_no(novo_tipo) 11: t.u <- "Bem Vindo" 12: escrever t.u 13:fim
Ver o exemplo: lista_ligada.alg Resultado: Bem Vindo
13
PORTUGOLVIANA
Manual da Linguagem
3.5. Listas Duplamente Ligadas São estruturas formadas por um conjunto de dados de forma a preservar a relação de ordem linear entre eles. Uma lista é composta por nós, os quais podem conter, cada um deles, um dado primitivo ou composto. Além dos dados, esta estrutura de dados armazena a referência para os elementos anterior e seguinte na lista. Para permitir a utilização de listas, o PortugolViana tem pré-definido um tipo de dados chamado lista_ligada. Neste tipo de dados estão implícitos dois elementos essenciais à utilização de listas: • •
Anterior - para referenciar o elemento anterior ao corrente. Seguinte - para referenciar o elemento seguinte ao corrente.
Além destes dois elementos, existe ainda a função novo_no, que permite criar um novo nó na lista em questão. Sintaxe: 1:tipo estrutura 2:inicio 3: ... 4: 5: ... 6:fim estrutura 7: 8:inicio 9: lista_ligada 10: <- novo_no 11: . <- < expressão> 12: .seguinte <- 13: .anterior <- 14:fim
Representação gráfica: Para uma melhor percepção do conceito de lista duplamente ligada, considera-se a seguinte representação gráfica: Lista duplamente ligada: Lista Dokmamente kigadaSeguinte Anterior Elemento
Anterior
Elemento
Seguinte
…
14
PORTUGOLVIANA
Manual da Linguagem
Exemplo: 1:tipo estrutura novo_tipo 2:inicio 3: texto u 4:fim estrutura 5: 6:inicio 7: lista_ligada novo_tipo t 8: t <- novo_no(novo_tipo) 9: t.u <- "Olá" 10: t.seguinte <- novo_no(novo_tipo) 11: t.anterior <- novo_no(novo_tipo) 12: t.anterior.u <- "seja" 13: t.seguinte.u <- "Bem Vindo" 14: 15: escrever t.u,", ",t.anterior.u," ",t.seguinte.u,"!" 16:fim
Ver o exemplo: lista_d_ligada.alg Resultado: Olá , seja Bem Vindo!
15
PORTUGOLVIANA
Manual da Linguagem
4. Operadores 4.1. Aritméticos 4.1.1. Operadores disponíveis para números inteiros Operador
Descrição
Assinatura
Exemplo
Resultado
+
Adição
+ : Inteiro , Inteiro -> Inteiro
x <- 8 + 12
x = 20
-
Subtracção
- : Inteiro , Inteiro -> Inteiro
x <- 45 - 6
x = 39
/
Divisão Inteira
/ : Inteiro , Inteiro -> Inteiro
x <- 24 / 3
x=8
*
Multiplicação
* : Inteiro , Inteiro -> Inteiro
x <- 5 * 9
x = 45
% ^
Resto da Divisão % : Inteiro , Inteiro -> Inteiro x <- 13 % 4 Inteira Potenciação
^ : Inteiro , Inteiro -> Inteiro
x <- 5 ^ 2
x=1 x = 25
Descrição: Operadores que utilizam exclusivamente variáveis ou valores inteiros Exemplo: 1:inicio 2: inteiro i1 <- 5 , i2 <- 2 3: escrever "operadores inteiros" 4: escrever "\n" , i1 , " + " , i2 , " = " , i1 + i2 5: escrever "\n" , i1 , " - " , i2 , " = " , i1 - i2 6: escrever "\n" , i1 , " * " , i2 , " = " , i1 * i2 7: escrever "\n" , i1 , " / " , i2 , " = " , i1 / i2 8: escrever "\n" , i1 , " % " , i2 , " = " , i1 % i2 9: escrever "\n" , i1 , " ^ " , i2 , " = " , i1 ^ i2 10:fim
Ver o exemplo: operadores_inteiro.alg Resultado: operadores inteiros 5 + 2 = 7 5 - 2 = 3 5 * 2 = 10 5 / 2 = 2 5 % 2 = 1 5 ^ 2 = 25
16
PORTUGOLVIANA
Manual da Linguagem
4.1.2. Operadores disponíveis para números reais: Operador Descrição
Assinatura
Exemplo
Resultado
+
Adição
+ : Real , Real -> Real
x <- 8.1 + 12.3
x = 20.4
-
Subtracção
- : Real , Real -> Real
x <- 4.5 - 2.6
x = 1.9
/
Divisão Inteira
/ : Real , Real -> Real
x <- 0.24 / 3
x = 0.08
*
Multiplicação
* : Real , Real -> Real
x <- 5 * 9.7
x = 48.5
^
Potenciação
^ : Real , Real -> Real
x <- 9 ^ 0.5
x = 3.0
Descrição: Operadores que utilizam variáveis ou valores numéricos em que pelo menos um elemento é do tipo real. Exemplo: 1:inicio 2: real i1 <- 5.0 , i2 <- 2.0 3: escrever "operadores reais" 4: escrever "\n" , i1 , " + " , 5: escrever "\n" , i1 , " - " , 6: escrever "\n" , i1 , " * " , 7: escrever "\n" , i1 , " / " , 8: escrever "\n" , i1 , " ^ " , 9:fim
i2 i2 i2 i2 i2
, , , , ,
" " " " "
= = = = =
" " " " "
, , , , ,
i1 i1 i1 i1 i1
+ * / ^
i2 i2 i2 i2 i2
Ver o exemplo: operadores_real.alg Resultado: operadores real 5.0 + 2.0 = 7.0 5.0 - 2.0 = 3.0 5.0 * 2.0 = 10.0 5.0 / 2.0 = 2.5 5.0 ^ 2.0 = 25.0
17
PORTUGOLVIANA
Manual da Linguagem
4.2. Lógicos Operador Descrição E OU XOU NAO
Assinatura
Exemplo
Resultado
E : Lógico , Lógico x <- Verdadeiro E x = Falso -> Lógico Falso OU : Lógico , x <- Verdadeiro OU Disjunção x = Verdadeiro Lógico -> Lógico Falso Disjunção XOU : Lógico , x <- Verdadeiro XOU x = Falso Exclusiva Lógico -> Lógico Verdadeiro NAO : Lógico -> Negação NAO Verdadeiro Falso Lógico
Conjunção
Descrição: Os operadores lógicos fornecem com resultado um valor lógico ( verdadeiro ou falso). Os operadores E, OU e XOU são operadores binários e o NAO é um operador unário. Exemplo: 1:inicio 2: logico l1 , l2 3: l1 <- verdadeiro 4: l2 <- falso 5: escrever "\n não " , 6: escrever "\n não " , 7: 8: escrever "\n\n" , l1 9: escrever "\n" , l1 , 10: escrever "\n" , l1 , 11: 12: l1 <- verdadeiro 13: l2 <- verdadeiro 14: escrever "\n\n" , l1 15: escrever "\n" , l1 , 16: escrever "\n" , l1 , 17: 18: l1 <- falso 19: l2 <- falso 20: escrever "\n\n" , l1 21: escrever "\n" , l1 , 22: escrever "\n" , l1 , 23:fim
l1 , "\t= " , nao l1 l2 , "\t= " , nao l2 , " e \t" , l2 , " = " , l1 e l2 " ou \t" , l2 , " = " , l1 ou l2 " xou \t" , l2 , " = " ,l1 xou l2
, " e \t" , l2 , " = " , l1 e l2 " ou \t" , l2 , " = " , l1 ou l2 " xou \t" , l2 , " = " ,l1 xou l2
, " e \t" , l2 , " = " , l1 e l2 " ou \t" , l2 , " = " , l1 ou l2 " xou \t" , l2 , " = " ,l1 xou l2
Ver o exemplo: operadores_logico.alg
18
PORTUGOLVIANA
Manual da Linguagem
Resultado: não VERDADEIRO = FALSO não FALSO = VERDADEIRO VERDADEIRO e FALSO = FALSO VERDADEIRO ou FALSO = VERDADEIRO VERDADEIRO xou FALSO = VERDADEIRO VERDADEIRO e VERDADEIRO = VERDADEIRO VERDADEIRO ou VERDADEIRO = VERDADEIRO VERDADEIRO xou VERDADEIRO = FALSO FALSO e FALSO = FALSO FALSO ou FALSO = FALSO FALSO xou FALSO = FALSO
19
PORTUGOLVIANA
Manual da Linguagem
4.3. Relacionais Operador
Descrição
Assinatura
= : Qualquer , Qualquer -> x = Verdadeiro Lógico =/= : Qualquer , Qualquer -> Diferente x =/= "Olá" Lógico > : Qualquer , Qualquer -> Maior 24 > 3 Lógico Maior ou >= : Qualquer , Qualquer -> 5 >= 9.7 Igual Lógico < : Qualquer , Qualquer -> Menor 9<5 Lógico Menor ou <= : Qualquer , Qualquer -> 0.7 <= 0.5 Igual Lógico Igual
= =/= > >= < <=
Exemplo
Resultado Falso Verdadeiro Verdadeiro Falso Falso Falso
Descrição: Os operadores relacionais fornecem como resultado um valor lógico ( verdadeiro ou falso), sendo somente possível utilizá-los para efectuar comparações: • • •
Se os operandos forem numéricos a comparação é feita com base no seu valor. Se os operandos forem texto a comparação é feita lexicograficamente. Se os operandos forem lógicos apenas estão disponíveis a igualdade e a diferença.
Exemplo: 1:inicio 2: real l1 <- 5.0 , l2 <3: escrever "\n" , l1 , " 4: escrever "\n" , l1 , " 5: escrever "\n" , l1 , " 6: escrever "\n" , l1 , " 7: escrever "\n" , l1 , " 8: escrever "\n" , l1 , " 9:fim
3 = " , l2 , "\t= " , l1 = l2 =/= " , l2 , "\t= " , l1 =/= l2 > " , l2 , "\t= " , l1 > l2 >= " , l2 , "\t= " , l1 >= l2 < " , l2 , "\t= " , l1 < l2 <= " , l2 , "\t= " , l1 <= l2
Ver o exemplo: operadores_relacionais.alg Resultado: 5.0 5.0 5.0 5.0 5.0 5.0
= 3.0 = FALSO =/= 3.0 = VERDADEIRO > 3.0 = VERDADEIRO >= 3.0 = VERDADEIRO < 3.0 = FALSO <= 3.0 = FALSO
20
PORTUGOLVIANA
Manual da Linguagem
4.4. Texto
Operador
Descrição
Assinatura
Exemplo
+: Texto/Caracter Concatenação de , x <- "Olá" + "Mundo" + texto Texto/Caracter ->Texto letra : Texto, Devolve o cracter Letra Inteiro (base 0) x <- letra("Olá",2) (texto,inteiro) da posição indicada -> Caracter [] : Texto , Devolve o cracter x <- "Viana"[3] texto[inteiro] da posição indicada Inteiro -> Caracter Devolve o comprimento : Comprimento comprimento de Texto -> comprimento("Portugol") (texto) um texto Inteiro Descrição:
Resultado
x = "Olá Mundo"
x = "á" x = "n" 8
Operadores que utilizam variáveis ou valores do tipo texto. Exemplo: 1:inicio 2: texto nome1 <-"Linguagem" 3: texto nome2 <-"Algoritmica" 4: texto nome3 5: nome3 <- nome1 + " " + nome2 6: escrever "nome1 = ", nome1,"\n" 7: escrever "nome2 = ", nome2,"\n" 8: escrever "nome1 + nome2 = ",nome3,"\n" 9: escrever "letra(nome1,4) = ", letra(nome1,4),"\n" 10: escrever "nome2[5] = ", nome2[5],"\n" 11: escrever "comprimento(nome3)=",comprimento(nome3),"\n" 12:fim
Ver o exemplo: operadores_texto.alg Resultado: nome1 = Linguagem nome2 = Algoritmica nome1 + nome2 = Linguagem Algoritmica letra(nome1,4) = u nome2[5] = i comprimento(nome3) = 21
21
PORTUGOLVIANA
Manual da Linguagem
4.5. Prioridade de Operadores Os operadores possuem uma prioridade uns relativamente aos outros, isto é, existe uma hierarquia de operadores, o que implica que as operações sejam realizadas por determinada ordem. A prioridade destes operadores é mais alta quanto menor o nível de hierarquia a que pertencem. •
•
•
As operações sucessivas dentro de um grupo efectuam-se da esquerda para a direita. A utilização de parêntesis, mesmo que não sejam estritamente necessários pode e deve ser aplicada com o intuito de aumentar a clareza nas expressões tratadas e diminuir as hipóteses de erro. A prioridade dos operadores pode ser alterada utilizando parêntesis, sendo as operações delimitadas por estes realizadas primeiro. Prioridade Nível 1 (Maior) Nível 2 * Nível 3 Nível 4 (Menor) =
Operadores NAO /
%
E
+ =/=
<
<=
>
OU >=
22
PORTUGOLVIANA
Manual da Linguagem
5. Entrada / Saída 5.1. Ler Sintaxe: ler variavel ler variavel1, variavel2
Descrição: Solicita a introdução de valores para as variáveis através da consola: • •
•
A leitura de uma variável deve ser precedida da sua declaração. É possível definir a leitura de várias variáveis desde que estas estejam separadas por vírgulas (,). Os valores introduzidos para cada variável devem ser compatíveis com o tipo definido na declaração da mesma.
Exemplo: 1:inicio 2: texto nome 3: escrever "qual o seu nome:" 4: ler nome 5: escrever "bem-vindo ao portugol " , nome 6:fim
Ver o exemplo: ler.alg Resultado: qual o seu nome: António bem-vindo ao portugol António
23
PORTUGOLVIANA
Manual da Linguagem
5.2. Escrever Sintaxe: escrever escrever escrever escrever escrever
variavel constante "texto" [expressão] variavel , "texto" , expressão , . . .,
Descrição: Escreve variáveis, constantes, expressões ou texto na consola. A mesma instrução pode escrever vários elementos desde que sejam separados por vírgulas (,). Existem três símbolos pré-definidos no texto: • • •
\n - mudança de linha (enter). \t - tabulação. \" - caracter aspas (").
Exemplo: 1:inicio 2: texto nome 3: escrever "qual o seu nome:" 4: ler nome 5: escrever "\nbem-vindo ao portugol \t\"" , nome , "\"" 6:fim
Vero o exemplo: escrever.alg Resultado: qual o seu nome: António bem-vindo ao portugol
"António"
24
PORTUGOLVIANA
Manual da Linguagem
6. Selecção 6.1. Se Sintaxe: se [condição] entao [instruções] senao [instruções] fimSe
ou: se [condição] entao [instruções] fimSe
Descrição: A estrutura condiocional - (Se...entao...senao) - é caracterizada pela avaliação de uma condição e se a condição for verdadeira, efectua uma sequência de acções (instruções referentes ao entao), caso a condição seja falsa efectua outra série de acções (instruções referentes ao senao). A condição deve ser uma variável lógica ou uma expressão com resultado lógico (operadores lógicos ou relacionais). Fluxograma:
25
PORTUGOLVIANA
Manual da Linguagem
Exemplo: 1:inicio 2: inteiro numero, r 3: escrever " introduza um numero: " 4: ler numero 5: r <- numero % 2 6: se r = 0 entao 7: escrever "numero par" 8: senao 9: escrever "numero impar" 10: fimse 11:fim
Ver o exemplo: se_par_impar.alg Resultado: introduza um numero: 5 numero impar
Outros exemplos: •
Ver o exemplo: equação de 2º grau.alg
26
PORTUGOLVIANA
Manual da Linguagem
6.2. Escolhe Sintaxe: Escolhe [variavel a testar] Caso [Expressão_1],. . .,[Expressão_1n],: [instruções] . . . . . . . . . . . Caso [Expressão_n],. . .,[Expressão_nn],: [instruções] Defeito: [instruções] FimEscolhe
Descrição: A estrutura condicional múltipla ( Escolhe) é caracterizada pela avaliação da variável a testar com as restantes expressões (expressão_1 . . . expressão_n ) e se a comparação for positiva executa as instruções do Caso e sai. A estrutura tem um caso por defeito ( opcional) que é executado quando todas as outras condições falharem. Fluxograma:
27
PORTUGOLVIANA
Manual da Linguagem
Exemplo: 1:inicio 2: caracter sexo 3: escrever "Qual o seu sexo? " 4: ler sexo 5: escrever "Olá " 6: escolhe sexo 7: caso "m" : 8: escrever "Homem" 9: caso "f" : 10: escrever "Mulher" 11: defeito : 12: escrever "Sexo indefinido" 13: fimescolhe 14: escrever ", bemvindo ao portugol" 15:fim
Ver o exemplo: nome_sexo.alg Resultado: Qual o seu sexo? m Olá Homem, benvindo ao Portugol
Outros exemplos: •
Ver o exemplo: ultimo_dia.alg
28
PORTUGOLVIANA
Manual da Linguagem
7. Repetição 7.1. Enquanto Sintaxe: enquanto [condição] faz [intruções] fimEnquanto
Descrição: A estrutura enquanto possibilita repetir a execução de uma ou várias instruções, enquanto uma determinada condição/expressão, do tipo lógico, tiver valor verdadeiro. Para que o ciclo termine é necessário que o valor da condição/expressão seja alterado dentro do ciclo, caso contrário, o ciclo entra em loop infinito. Há ainda a salientar dois aspectos: 1. O corpo do ciclo pode não ser executado nenhuma vez, caso o valor da condição/expressão seja falso, visto essa condição/expressão ser verificada antes que se inicie o ciclo. 2. Normalmente não é possível determinar, à partida, o número de vezes que o corpo do ciclo é excutado, porque o valor da condição que especifica o término do ciclo é alterado durante a execução desse ciclo não se sabendo que valor lhe vai ser atribuído. Fluxograma:
29
PORTUGOLVIANA
Manual da Linguagem
Exemplo: 1:inicio 2: inteiro contador 3: contador <- 0 4: enquanto contador < 10 faz 5: escrever contador , "\t" 6: contador <- contador + 1 7: fimenquanto 8:fim
Ver o exemplo: enquanto_conta10.alg Resultado: 0
1
2
3
4
5
6
7
8
9
30
PORTUGOLVIANA
Manual da Linguagem
7.2. Repete Sintaxe: repete [instruções] ate[condição]
Descrição: Esta estrutura permite repetir uma ou mais instruções, até que uma determinada condição/expressão, do tipo lógico, tenha um valor verdadeiro. Ao contrário da estrutura enquanto, são executadas as instruções incluídas no corpo do ciclo e, só depois é verificada a condição/expressão. Se o valor for falso o corpo do ciclo é de novo executado, a execução termina apenas quando esse valor for verdadeiro. Assim, o corpo do ciclo é executado pelo menos uma vez. Tal como na estrutura enquanto não é possível determinar, à partida, o número de vezes que o corpo do ciclo é executado. Fluxograma:
Exemplo: Solicita a introdução de um mês até o utilizador introduzir um valor válido ( entre 1 e 12). 1:inicio 2: inteiro mes 3: repete 4: escrever "introduza um mes :" 5: ler mes 6: ate mes > 0 e mes < 13 7: escrever "\nmes introduzido :" , mes 8:fim
31
PORTUGOLVIANA
Manual da Linguagem
Ver o exemplo: repete_pede_mes.alg Resultado: introduza um mes :-10 introduza um mes :20 introduza um mes :5 mes introduzido :5
Outros exemplos: •
Ver o exemplo: DataNascimento.alg
32
PORTUGOLVIANA
Manual da Linguagem
7.3. Para Sintaxe: para [variável numerica] de [valor inicial] ate [valor final] passo [valor de separação] [intruções] proximo
para [variável numerica] de [valor inicial] ate [valor final] [intruções] proximo
Descrição: A estrutura para é utilizada para efectuar ciclos incondicionais. A execução das instruções, do corpo do ciclo, é controlada por uma variável ( variável numérica), que tem que ser de um tipo enumerável. O corpo do ciclo é executado para uma sequência de valores da variável de controlo. Quando é encontrada uma estrutura para a variável de controlo é inicializada com o primeiro valor da sequência (valor inicial). De seguida, executa as instruções incluídas no corpo do ciclo e actualiza a variável de controlo com o próximo valor da sequência ( passo). A execução do ciclo pára com o último valor da sequência ( ate). Caso o passo não seja definido, o passo é de mais ou menos uma unidade de forma a poder percorrer o intervalo entre o valor inicial e o final de forma crescente ou decrescente. Antes do ciclo ser executado já se sabe qual o número de vezes que este irá ser executado, ao contrário das outras estruturas de repetição.
33
PORTUGOLVIANA
Manual da Linguagem
Fluxograma:
Exemplo: 1:inicio 2: inteiro contador 3: para contador de 0 ate 9 passo 1 4: escrever contador , "\t" 5: proximo 6:fim
Ver o exemplo: para_conta10.alg Resultado: 0
1
2
3
4
5
6
7
8
9
34
PORTUGOLVIANA
Manual da Linguagem
7.4. Faz Sintaxe: Faz [instruções] Enquanto[condição]
Descrição: Repete as instruções até que a condição seja falsa. Fluxograma:
Exemplo: Solicita a introdução de um mês até o utilizador introduzir um valor válido (entre 1 e 12). 1:inicio 2: inteiro mes 3: faz 4: escrever "introduza um mes :" 5: ler mes 6: enquanto mes < 0 ou mes > 13 7: escrever "\nmes introduzido :" , mes 8:fim
Ver o exemplo: faz_pede_mes.alg Resultado: introduza um mes :-10 introduza um mes :20 introduza um mes :5 mes introduzido :5
35
PORTUGOLVIANA
Manual da Linguagem
8. Funções 8.1. Funções Pré-Definidas Na linguagem PortugolViana estão definidas as seguintes funções matemáticas e trigonométricas. 8.1.1. ABS Sintaxe: Função abs(valor)
Descrição
Assinatura
Retorna o valor absoluto abs : Real -> Real
Exemplo
Resultado
x <- abs(-2)
x=2
Descrição: Retorna o valor absoluto - módulo - de um número. Exemplo: 1:inicio 2: real num 3: para num de - 2 ate 2 passo 0.5 4: escrever abs ( num ) , "\t" 5: proximo 6:fim
Ver o exemplo: modulo.alg Resultado: 2.0
1.5
1.0
0.5
0.0
0.5
1.0
1.5
2.0
36
PORTUGOLVIANA
Manual da Linguagem
8.1.2. ALEATORIO Sintaxe: Função
Descrição
Assinatura
Exemplo
Resultado
Retorna um aleatorio : -> Real x <- aleatorio() x=0.21036507679 aleatorio() número aleatório (entre 0 e 1) Descrição: Retorna um número real, aleatório, entre 0 e 1. Exemplo: 1:inicio 2: inteiro numero , contador 3: escrever "chave de totoloto :" 4: para contador de 1 ate 6 5: numero <- aleatorio ( ) * 47 + 1 6: escrever numero , "\t" 7: proximo 8:fim
Ver o exemplo: totoloto.alg Resultado: chave de totoloto : 31
47
36
22
20
7
37
PORTUGOLVIANA
Manual da Linguagem
8.1.3. ARRED: Sintaxe: Função arred(valor)
Descrição
Assinatura
Exemplo
Arredondamento de arred : Real -> Inteiro x <- arred(12.3) um número real
Resultado x = 12
Descrição: Retorna o arredondamento, por defeito, de um número real. Exemplo: 1:inicio 2: real num 3: escrever "Introduza um número real: \n" 4: ler num 5: escrever "O número " , num , " arredondado é = " , arred ( num ) 6:fim
Ver o exemplo: arred.alg Resultado: Introduza um número real: 9.5 O número 9.5 arredondado é = 9
38
PORTUGOLVIANA
Manual da Linguagem
8.1.4. EXP Sintaxe: Função
Descrição
Assinatura
Retorna o valor da exp(valor) função exponencial exp : Real -> Real ( e ^ x)
Exemplo
Resultado
x <- exp(1) x = 2.7182818284
Descrição: Retorna o resultado de e (número de Nepper) elevado a valor. Exemplo: 1:inicio 2: real expoente , valor 3: expoente <- 1 4: valor <- exp ( expoente ) 5: escrever " o valor do numero de nepper é " , valor 6:fim
Ver o exemplo: expoente.alg Resultado: o valor do numero de nepper é 2.7182818284590455
39
PORTUGOLVIANA
Manual da Linguagem
8.1.5. FRAC Sintaxe: Função
Descrição
frac(valor)
Retorna a parte decimal de um número real
Assinatura
Exemplo
Resultado
frac : Real -> Inteiro x <- frac(123.456) x = 456
Descrição: Retorna a parte decimal de um número real. Exemplo: 1:inicio 2: real num 3: escrever "Introduza um número real: \n" 4: ler num 5: escrever "A parte decimal do número " , num , " é " , frac ( num ) 6:fim
Ver o exemplo: frac.alg Resultado: Introduza um número real: 3235.958 A parte decimal do número 3235.958 é 958
40
PORTUGOLVIANA
Manual da Linguagem
8.1.6. INT Sintaxe: Função int(valor)
Descrição
Assinatura
Exemplo
Retorna a parte inteira int : Real ->Inteiro x <- int(123.456) de um número real
Resultado x = 123
Descrição: Retorna a parte inteira de um número real. Exemplo: 1:inicio 2: real num 3: escrever "Introduza um número real: \n" 4: ler num 5: escrever "A parte inteira do número " , num , " é " , int ( num ) 6:fim
Ver o exemplo: int.alg Resultado: Introduza um número real: 56.32 A parte inteira do número 56.32 é 56
41
PORTUGOLVIANA
Manual da Linguagem
8.1.7. LN Sintaxe: Função ln(valor)
Descrição
Assinatura
Exemplo
Calcula o logaritmo ln : Real -> Real x <- ln(2.718281828459 ) - base e
Resultado x = 1.0
Descrição: Calcula o valor do logaritmo, de base e, do parâmetro. Exemplo: 1:inicio 2: real numero , valor 3: numero <- exp ( 1 ) 4: valor <- ln ( numero ) 5: escrever "ln(" , numero , ") = " , valor 6:fim
Ver o exemplo: ln.alg Resultado: ln(2.7182818284590455) = 1.0
42
PORTUGOLVIANA
Manual da Linguagem
8.1.8. LOG Sintaxe: Função
Descrição
Assinatura
Exemplo
Resultado
log(valor)
Calcula o logaritmo base 10
log : Real -> Real
x <- log(10.0)
x = 1.0
Descrição: Calcula o valor do logaritmo, de base 10, do valor do parâmetro. Exemplo: 1:inicio 2: real numero , valor 3: numero <- 10 4: valor <- log ( numero ) 5: escrever "logaritmo(" , numero , ") = " , valor 6:fim
Ver o exemplo: log.alg Resultado: logaritmo(10.0) = 1.0
43
PORTUGOLVIANA
Manual da Linguagem
8.1.9. POTENCIA Sintaxe: Função
Descrição
potencia(valor,expoente)Potenciação
Assinatura
Exemplo
Resultado
potencia : Real , x <- potencia(16,2) x = 256 Real -> Real
Descrição: Calcula o resultado do valor elevado ao expoente (valor ^ expoente). Exemplo: 1:inicio 2: real num 3: real expoente 4: escrever "Introduza um número real: " 5: ler num 6: escrever "Introduza o expoente : " 7: ler expoente 8: escrever "O resultado de potencia(",num," , ",expoente, ") é = " , potencia ( num , expoente ) 9:fim
Ver o exemplo: potencia.alg Resultado: Introduza um número real: 5 Introduza o expoente : 3 O resultado de potencia ( 5.0 , 3.0 ) é = 125.0
44
PORTUGOLVIANA
Manual da Linguagem
8.1.10. Raiz Sintaxe: Função raiz(valor)
Descrição
Assinatura
Exemplo
Calcula a raiz raiz : Real (positivo) -> Real x <- raiz(16) quadrada
Resultado x=4
Descrição: Calcula o valor da raiz quadrada do valor do parâmetro. Exemplo: 1:inicio 2: real numero , valor 3: numero <- 9 4: valor <- raiz ( numero ) 5: escrever "raiz quadrada(" , numero , ") = " , valor 6:fim
Ver o exemplo: raiz.alg Resultado: raiz quadrada(9.0) = 3.0
45
PORTUGOLVIANA
Manual da Linguagem
8.1.11. ACOS Sintaxe: Função acos(valor)
Descrição
Assinatura
Exemplo
Calcula o valor do acos : Real (entre -1 e 1) -> x <- acos(1) arco-cosseno Real
Resultado x = 0.0
Nota: O valor do ângulo é dado em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <3.1415926535897932384626433832795 3: escrever "O valor de acos(", -1,") = ",acos( -1 )," , correspondendo a ",acos( -1 )/angulo," PI." 4:fim
Ver o exemplo: acos.alg Resultado: O valor de acos(-1) = 3.141592653589793 , correspondendo a 1.0 PI.
46
PORTUGOLVIANA
Manual da Linguagem
8.1.12. ACTG Sintaxe: Função
Descrição
Assinatura
Calcula o valor do actg(valor) arco-cotangente actg : Real -> Real
Exemplo
Resultado
x <- actg(1) x = 1.2732395447
Nota: O valor do ângulo é dado em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de actg(",-1,") = ",actg( -1 )," , correspondendo a ",actg( 1 )/angulo," PI." 4:fim
Ver o exemplo: actg.alg Resultado: O valor de actg(-1) = -1.2732395447351628 , correspondendo a -0.4052847345693511 PI.
47
PORTUGOLVIANA
Manual da Linguagem
8.1.13. ASEN Sintaxe: Função asen(valor)
Descrição
Assinatura
Exemplo
Calcula o valor asen : Real (entre -1 e 1) -> x <- asen(1) do arco-seno Real
Resultado x = 1.570796
Nota: O valor do ângulo é dado em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de asen(", 1,") = ",asen( 1 )," , correspondendo a ",asen( 1 )/angulo," PI." 4:fim
Ver o exemplo: asen.alg Resultado: O valor de asen(1) = 1.5707963267948966 , correspondendo a 0.5 PI.
48
PORTUGOLVIANA
Manual da Linguagem
8.1.14. ATAN Sintaxe: Função atan(valor)
Descrição
Assinatura
Calcula o valor do acos : Real -> Real arco-tangente
Exemplo
Resultado
x <- atan(1) x = 0.7853981633
Nota: O valor do ângulo é dado em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de atan(",1,") = ",atan( 1 )," , correspondendo a ",atan( 1 )/angulo," PI." 4:fim
Ver o exemplo: atan.alg Resultado: O valor de atan(1) = 0.7853981633974483 , correspondendo a 0.25 PI.
49
PORTUGOLVIANA
Manual da Linguagem
8.1.15. COS Sintaxe: Função cos(angulo)
Descrição
Assinatura
Exemplo
Calcula o valor cos : Real -> Real x <- cos(3.141592653589) do cosseno
Resultado x = -1.0
Nota: O valor do ângulo deverá de ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de cos(",angulo,") = ",cos ( angulo ),", correspondendo a cos(180º)." 4:fim
cos.alg Resultado: O valor de cos(3.141592653589793) = -1.0 , correspondendo a cos(180º).
50
PORTUGOLVIANA
Manual da Linguagem
8.1.16. COSH Sintaxe: Função cosh(angulo)
Descrição
Assinatura
Exemplo
Resultado
Calcula o valor do cosh : Real -> Real x <- cosh(3.1415926) x = 11.591 coseno-hiperbólico
Nota: O valor do ângulo é dado em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de cosh(",angulo,") =",cosh(angulo), "." 4:fim
Ver o exemplo: cosh.alg Resultado: O valor de cosh(3.141592653589793) = 11.591953275521519.
51
PORTUGOLVIANA
Manual da Linguagem
8.1.17. CTG Sintaxe: Função
Descrição
Assinatura
Exemplo
Resultado
Calcula o valor ctg : Real x Real ctg(0.7853981634974483 ) Nota: O valor do ângulo deverá de ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de ctg(",angulo/4,") = ", ctg ( angulo/4 ),", correspondendo a ctg(45º)." 4:fim
Ver o exemplo: ctg.alg Resultado: O valor de ctg(0.7853981) = 1.0, correspondendo a ctg(45º).
52
PORTUGOLVIANA
Manual da Linguagem
8.1.18. CTGH Sintaxe: Função ctgh(angulo ctgh( angulo))
Descrição
Assinatura
Exemplo
Resultado
Calcula o valor da ctgh : Real -> Realx <- ctgh( ctgh(3.14159 3.14159)) x = 1.003 cotangente-hiperbólica
Nota: O valor do ângulo deve ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3.1415926535897932384626 3: escrever "O valor de ctgh(",angulo,") ctgh(",angulo,") = ", ctgh(angulo ctgh( angulo) ),"." 4:fim
Ver o exemplo: ctgh.alg Resultado: O valor de ctgh(3.141592653589793) ctgh(3.141592653589793) = 1.0037418731973213. 1.0037418731973213.
53
PORTUGOLVIANA
Manual da Linguagem
8.1.19. SEN Sintaxe: Função sen(angulo sen( angulo))
Descrição
Assinatura Assinatura
Exemplo
Resultado
Calcula o valor do sen sen : Real Real -> Real Real x <<- sen( sen(1.5707963267 1.5707963267)) x = 1.0 seno
Nota: O valor do ângulo deverá de ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3.1415926535897932384626 3: escrever "O valor de sen(",angulo / 2,") = ", sen ( angulo / 2 ),", correspondendo a sen(90º)." 4:fim
Ver o exemplo: sen.alg Resultado: O valor de sen(1.5707963267948966) sen(1.5707963267948966) = 1.0 , correspondendo correspondendo a sen(90º).
54
PORTUGOLVIANA
Manual da Linguagem
8.1.20. SENH Sintaxe: Função
Descrição
Assinatura
Exemplo
Resultado
Calcula o valor do senh(3.14159 3.14159)) x = 11.5487 senh(angulo senh( angulo)) seno-hiperbólico senh : Real -> Real x <- senh( Nota: O valor do ângulo deve ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3.1415926535897932384626 3: escrever "O valor de senh(",angulo,") senh(",ang ulo,") = ", senh( angulo ),"." 4:fim
Ver o exemplo: senh.alg Resultado: O valor de senh(3.141592653589793) senh(3.141592653589793) = 11.548739357257748. 11.548739357257748.
55
PORTUGOLVIANA
Manual da Linguagem
8.1.21. TAN Sintaxe: Função
Descrição
Assinatura
Exemplo
Resultado
tan(angulo)
Calcula o valor da tangente
tan : Real -> Real
x <- tan(0.785398)
x = 1.0
Nota: O valor do ângulo deverá de ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de tan(",angulo/4,") = ", tan ( angulo/4 ),", correspondendo a tan(45º)." 4:fim
Ver o exemplo: tan.alg Resultado: O valor de tan(0.7853981634974483) = 0.9999999999999999 , correspondendo a tan(45º).
56
PORTUGOLVIANA
Manual da Linguagem
8.1.22. TANH Sintaxe: Função
Descrição
Calcula o valor da tanh(angulo) tangente-hiperbólica
Assinatura
Exemplo
Resultado
tanh : Real -> Real x <- tanh(3.14) x = 0.9962
Nota: O valor do ângulo deve ser introduzido em radianos. π = 3.1415926535897932384626433832795 π rad = 180º Exemplo: 1:inicio 2: constante real angulo <- 3.1415926535897932384626 3: escrever "O valor de tanh(",angulo,") = " , tanh(angulo),"." 4:fim
Ver o exemplo: tanh.alg Resultado: O valor de tanh(3.141592653589793) = 0.99627207622075.
57
PORTUGOLVIANA
Manual da Linguagem
8.2. Definição 8.2.1. Definição de Funções Para lidar com programas extensos é necessário dividi-los em módulos que possam ser analisados de forma independente. Uma função implementa uma parte do algoritmo, sendo um conjunto de instruções "encapsulado", e devendo ter poucas instruções. • •
Uma tarefa complexa é subdividida em diversas tarefas mais simples. Cada uma dessas tarefas pode ainda ser dividida em tarefas mais elementares.
Procedendo desta forma, obtêm-se no final, tarefas elementares muito facilmente codifcáveis. Os módulos resultantes são mais facilmente compreendidos, testados, corrigidos e alterados. Elementos Fundamentais: •
•
• •
Nome: Designação pela qual a função é chamada. (Terá de respeitar as regras de nomeação de identificadores.) Parâmetros: Informação fornecida ao módulo ou retornada pelo módulo para o programa principal. (Não é obrigatório existirem parâmetros numa função.) Código: Instruções que implementam a função. Entrada e Saída: Uma função deve possuir uma única via de entrada e uma única via de saída. (Não é obrigatório existir Entrada ou Saída numa função.)
Sintaxe: funcao nome ( parametro_1…n) inicio ... [instruções] ... retornar fimfuncao inicio ... [instruções] ... fim
58
PORTUGOLVIANA
Manual da Linguagem
Exemplo: Calcula o quadrado de um número inteiro introduzido pelo utilizador. 1:funcao real quad(inteiro a) //definicao da funcao quad aceitando um inteiro como parametro de entrada 2:inicio 3: real z 4: z <- a * a 5: retornar z //devolucao do resultado ao algoritmo principal do mesmo tipo que a funcao quad 6:fimfuncao 7: 8:inicio 9: inteiro x 10: real y 11: escrever "Introduza um número inteiro: " 12: ler x 13: y <- quad(x) //chamada da funcao quad 14: escrever x , " elevado ao quadrado é = " , y 15:fim
Ver o exemplo: quad.alg Execução de um algoritmo com funções: Durante a execução do algoritmo principal, quando se encontra uma instrução que chama uma função (linha 13), a execução do primeiro é interrompida. A seguir, passa-se à execução das instruções do corpo da função ( linhas 1 a 6). Depois de executada a última instrução da função ( linha 5), retoma-se a execução do algoritmo que a chamou (no caso, o algoritmo principal) no ponto onde foi interrompida ( linha 13) e prossegue-se pela instrução imediatamente a seguir (linha 14). Vantagens do uso de Funções: •
•
•
•
Simplicidade: Cada sub-problema é mais simples de resolver. No caso de funções usadas repetidamente, só é necessário escrevê-la uma vez. Manutenção: Reduzidos custos e tempos de alteração de um programa. As funções podem ser substituídas ou alteradas independentemente. Divisão de tarefas: Permite a distribuição das tarefas de programação pelos diferentes programadores. Eficiência: Permite a utilização de funções existentes em bibliotecas de software.
59
PORTUGOLVIANA
Manual da Linguagem
8.2.2. Parâmetros e Argumentos O conceito de Função é originário da ideia de função matemática, onde uma função é uma relação em que, a um ou mais valores designados por argumentos, se faz corresponder um outro valor, chamado resultado. Para que possa iniciar a execução das instruções no seu corpo, por vezes, uma função precisa receber dados do algoritmo que o chamou e, ao terminar a sua tarefa, a função deve fornecer ao algoritmo que o chamou os resultados da mesma. Para que exista comunicação bidireccional são necessários: • •
Parâmetros na função que permitam receber a informação. Argumentos na chamada da função.
IMPORTANTE: A passagem de testemunho da informação do algoritmo principal (argumentos) e a função (parâmetros) devem fazer-se corresponder por posição e tipo . 8.2.3. Passagem por Valor •
•
O parâmetro recebe o valor do argumento correspondente e pode modificar este valor sem que, no final da função, o argumento seja actualizado. Os parâmetros são só de entrada e permite que os argumentos sejam variáveis, constantes ou expressões.
Sintaxe: 1:funcao nome ( variavel parametro_1…n) 2:inicio 3: ... 4: [instruções] 5: ... 6: retornar 7:fimfuncao 8: 9:inicio 10: ... 11: [instruções] 12: ... 13: <- (,...) 14: ... 15:fim
60
PORTUGOLVIANA
Manual da Linguagem
Exemplo: 1:funcao inteiro pv ( inteiro x ) 2:inicio 3: x <- x + 1 4: escrever "Resultado na função: x= ", x , "\n" 5: retornar x 6:fimfuncao 7: 8:inicio 9: inteiro a,b 10: a <- 2 11: escrever "pv ( ",a," )\n" 12: c <- pv ( a ) 13: escrever "Resultado no algoritmo principal: a=",a,"\n" 14:fim
Ver o exemplo: exemplo_pv.alg Análise do exemplo: A função pv recebe um parâmetro passado por valor e incrementa-o ( linha 3 ), escrevendo o resultado desse incremento na consola ( linha 4). No algoritmo principal, quando a função pv é chamada ( linha 12), é-lhe enviado o valor armazenado na variável a (linha 10); depois da execução da função, podemos verificar que apesar de o valor ter sido alterado na função, este não é alterado no algoritmo principal. (ver resultado) Resultado: pv ( 2 ) Resultado na função: x=3 Resultado no algoritmo principal: a=2
Em resumo, a passagem por valor permite a utilização e alteração desse valor dentro da função, sem que tal vá afectar a execução do algoritmo principal, pois qualquer alteração ao valor passado inicialmente não é devolvida.
61
PORTUGOLVIANA
Manual da Linguagem
8.2.4. Passagem por Referência •
•
•
Quando uma função com parâmetros passados por referência é chamada, o espaço de memória ocupado pelos argumentos é partilhado pelos parâmetros correspondentes. Assim, as eventuais modificações feitas nos parâmetros também afectam os argumentos correspondentes. Na passagem por referência os parâmetros são de entrada/saída.
Sintaxe: 1:funcao nome ( ref variavel parametro_1…n) 2:inicio 3: ... 4: [instruções] 5: ... 6: retornar 7:fimfuncao 8: 9:inicio 10: ... 11: [instruções] 12: ... 13: <- (ref ) 14: ... 15:fim
Exemplo: 1:funcao inteiro pref (ref inteiro x) 2:inicio 3: x <- x + 1 4: escrever "Resultado na função: x=", x ,"\n" 5: retornar x 6:fimfuncao 7: 8:inicio 9: inteiro a,b 10: a <- 2 11: escrever "pref ( ref ",a," )\n" 12: b <- pref ( ref a ) 13: escrever "Resultado no algoritmo principal: a=",a,"\n" 14:fim
Ver o exemplo: exemplo_pref.alg
62
PORTUGOLVIANA
Manual da Linguagem
Análise do exemplo: A função pref recebe um parâmetro passado por referência e incrementa-o - à semelhança do exemplo de passagem por valor - ( linha 3 ), escrevendo o resultado desse incremento na consola ( linha 4). No algoritmo principal, quando a função pref é chamada (linha 12), é-lhe enviada a variável a (linha 10); depois da execução da função, podemos verificar que é alterado no algoritmo principal. (ver resultado) Resultado: pref (ref 2 ) Resultado na função: x=3 Resultado no algoritmo principal: a=3
Em resumo, a passagem por referência permite a utilização e alteração do valor da variável dentro da função, indo, no entanto, afectar a execução do algoritmo principal, pois qualquer alteração ao valor passado inicialmente é devolvida.
63
