Edmo Sérgio Ribeiro Bezerra€¦ · ii Bezerra,Edmo Sérgio Ribeiro Uma calculadora intervalar em...

i

Pós-Graduação em Ciência da Computação

Um a Calc u ladora In t ervalar em J ava

Por

Edmo Sérgio Ribeiro Bezerra

Dissertação de Mestrado

Universidade Federal de Pernambuco [email protected]

www.cin.ufpe.br/~posgraduacao

RECIFE, AGOSTO / 2006

ii

Bezerra,Edmo Sérgio Ribeiro Uma calculadora intervalar em Java / Edmo Sérgio Ribeiro Bezerra. Recife: O autor, 2006.

xii, 71 folhas: il., fig., tab.

Dissertação (mestrado) Universidade Federal de Pernambuco. CIN. Ciência da Computação, 2006.

Inclui bibliografia.

1. Análise intervalar (Matemática). 2. Computação Científica. 3. Linguagem XSC. 4. Java. I.Título.

511.42 CDD (22.ed.) MEI2007-045

iii

Universidade Federal de Pernambuco

CENTRO DE INFORMÁTICA

PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO

EDMO SÉRGIO RIBEIRO BEZERRA

Uma Calculadora Intervalar em Java"

ESTE TRABALHO FOI APRESENTADO À PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO DO CENTRO DE INFORMÁTICA DA UNIVERSIDADE FEDERAL DE PERNAMBUCO COMO REQUISITO PARCIAL PARA OBTENÇÃO DO GRAU DE MESTRE EM CIÊNCIA DA COMPUTAÇÃO.

ORIENTADOR(A): Marcília Andrade Campos

RECIFE, AGOSTO/2006

iv

DEDICATÓRIA

Dedico esta dissertação à minha família, em

especial a meu pai, minha mãe e meu

irmão, base para todas as minhas

conquistas.

v

AGRADECIMENTOS

Inicialmente agradeço a Deus que considero base para todos os passos que

damos durante nossa caminhada. Desejo que esta dissertação seja motivo de

orgulho para meus pais e irmão, de quem recebi total e completa benevolência

durante o período de mestrado.

Profundamente, agradeço a professora Marcília Andrade Campos que além

de minha orientadora e mestra, considero uma amiga que me acompanhou durante

os anos de mestrado e graduação na UFPE.

Aos amigos Renato Ferreira Viana e Bruno José Torres Fernandes, que

juntamente comigo, formamos o grupo de estudo de Java Intervalar do Centro de

Informática, fica além da amizade obtida, o agradecimento pela ajuda no

desenvolvimento da biblioteca Intervalar e dos trabalhos em equipe concluídos.

Também, em especial, deixo registrados agradecimentos a Janine de Aguiar

Loureiro, amiga desde a graduação, durante todos os projetos acadêmicos e,

durante boa parte do mestrado. Sinceramente retribuo toda a amizade, paciência e

apoio recebidos.

vi

SUMÁRIO

1. Introdução ...............................................................................................................................1

2. Fundamentos ...........................................................................................................................5

2.1 Representação dos reais nos computadores ......................................................................6

2.1.1 Erros Numéricos ........................................................................................................6

2.1.2 Sistema de ponto flutuante.........................................................................................8

2.2 Ponto Flutuante em Java .................................................................................................12

2.3 Matemática Intervalar .....................................................................................................16

2.3.1 Intervalo de Números Reais.....................................................................................17

2.3.2 Conjunto de Intervalos.............................................................................................18

2.3.3 Operações aritméticas ..............................................................................................19

2.3.3.1 Soma Intervalar.....................................................................................................20

2.3.3.2 Pseudo Inverso Aditivo Intervalar ........................................................................20

2.3.3.3 Subtração Intervalar ..............................................................................................20

2.3.3.4 Multiplicação Intervalar........................................................................................20

2.3.3.5 Pseudo Inverso Multiplicativo Intervalar .............................................................21

2.3.3.6 Divisão Intervalar, ................................................................................................21

2.3.4 Operações entre Conjuntos ......................................................................................21

2.3.4.1 Interseção de Intervalos ........................................................................................21

2.3.4.2 União de Intervalos ...............................................................................................22

2.3.4.3 União Convexa de Intervalos................................................................................22

2.3.5 Outras operações......................................................................................................22

2.3.5.1 Distância entre Intervalos .....................................................................................22

2.3.5.2 Diâmetro de um Intervalo .....................................................................................23

2.3.5.3 Ponto Médio de um Intervalo ...............................................................................23

2.3.7 Operações matriciais................................................................................................24

2.3.7 Operações matriciais................................................................................................25

2.3.7.1 Soma de matrizes intervalares ..............................................................................25

2.3.7.2 Subtração de matrizes intervalares .......................................................................25

2.3.7.3 Multiplicação de matrizes intervalares .................................................................26

2.3.7.4 Interseção de matrizes intervalares .......................................................................26

2.3.7.5 União de matrizes intervalares..............................................................................27

vii

2.4 Considerações finais .......................................................................................................28

3. Java-XSC ..............................................................................................................................29

3.1 Biblioteca Intervalar Java ...............................................................................................30

3.1.1 Análise e Modelagem da API ..................................................................................31

3.1.2 Implementação.........................................................................................................34

3.1.2.1 Módulo de Arredondamentos ...............................................................................35

3.1.2.2 Módulo Intervalar .................................................................................................36

3.1.2.3 Módulo Matricial ..................................................................................................39

3.1.2.4 Módulo Transcendental ........................................................................................42

3.1.2.5 Módulo Trigonométrico........................................................................................42

3.1.2.6 Módulo Estatístico ................................................................................................44

3.1.2.7 Módulo Utilitário ..................................................................................................45

3.1.3 Testes e Validação .......................................................................................................46

3.2 Calculadora Intervalar.....................................................................................................50

3.2.1 Técnica 1: Abstração ...............................................................................................50

3.2.2 Técnica 2: Brainstorm..............................................................................................51

3.2.3 Técnica 3: Prototipação ...........................................................................................52

3.2.4 Instalação e uso da Calculadora Java-XSC..............................................................58

5. Conclusôes e Trabalhos futuros ............................................................................................66

Referências................................................................................................................................69

viii

RESUMO

Uma abordagem para controlar os erros de resultados de computações numéricas é

utilizar a Matemática Intervalar. A Matemática Intervalar é uma teoria matemática

que propõe solucionar problemas relacionados às inexatidões e imprecisões que

aparecem na computação científica. Dessa maneira, a utilização de técnicas

intervalares é uma alternativa para alcançar limites garantidos para os resultados de

computações. Portanto, este trabalho tem como objetivos (i) implementar uma

biblioteca XSC para suprir as necessidades de Java relacionadas com a

implementa;ao dos números reais através dos números de ponto flutuante e (ii)

desenvolver uma calculadora intervalar que resume e permite o uso das operações

aritméticas, lógicas, transcendentais, trigonométricas e estatísticas que compõe a

biblioteca intervalar Java. As facilidades da linguagem Java, entre elas reuso e

aspectos de herança, permitiram o desenvolvimento modular e robusto da biblioteca

intervalar. Quando comparados como o software IntpakX, os resultados obtidos com

a calculadora Java-XSC foram satisfatórios considerando a métrica distância.

Palavras-Chaves: Matemática intervalar, Computação científica, Linguagens XSC,

Java.

ix

ABSTRACT

An approach for controlling errors in the results of numerical computations is the use

of Intervalar Mathematics. Intervalar Mathematics is a mathematical theory that

tackles the problem of lack of precision in scientific computation. The use of

intervalar techniques is an alternative to guarantee the limits of the results of

computations. This work has as objectives: (a) to develop a Java XSC library that

provides implementation for real numbers using floating-point, avoiding the limitations

of the Java primitives; and (b) to develop an intervalar calculator that allows the use

of arithmetical, logical, transcendental, trigonometrical and statistical operations that

are part of the Java intervalar library. Some features of the Java language, like

reusability and inheritance, allowed the modular and robust development of the

intervalar library. When compared to InpakX, the results obtained with the Java-XCS

calculator were satisfactory regarding the distance metric.

Keywords: Intervalar Mathematics, Scientific Computation, XSC Languages, Java.

x

LISTA DE FIGURAS

Figura 1: Seqüência de passos para processamento numérico....................................................7

Figura 2: Representação de número de ponto flutuante .............................................................8

Figura 3: Representação do sistema de ponto flutuante .............................................................8

Figura 4: Representação do zero real em F.................................................................................9

Figura 5: Representação do mínimo e máximo em F .................................................................9

Figura 6: Número de elementos de F..........................................................................................9

Figura 7: Distribuição dos números reais na reta .....................................................................10

Figura 8: Representação da primitiva float...............................................................................14

Figura 9: Representação da primitiva double ...........................................................................14

Figura 10: Representação matemática do conjunto de intervalos.............................................18

Figura 11: Representação gráfica do espaço dos Intervalos .....................................................18

Figura 12: Estrutura hierárquica da representação numérica....................................................19

Figura 13: Representação das operações básicas intervalares ..................................................20

Figura 14: Representação da operação intervalar de soma.......................................................20

Figura 15: Representação da operação seudo pnverso aditivo intervalar .................................20

Figura 16: Representação da operação intervalar de subtração ................................................20

Figura 17: Representação da operação intervalar de multiplicação..........................................20

Figura 18: Representação da operação intervalar de pseudo inverso multiplicativo................21

Figura 19: Representação da operação intervalar de divisão....................................................21

Figura 20: Representação da operação intervalar de interseção ...............................................21

Figura 21: Representação da operação intervalar de união ......................................................22

Figura 22: Representação da operação intervalar de união convexa ........................................22

Figura 23: Representação da distância intervalar .....................................................................22

Figura 24: Representação do diâmetro de um intervalo ...........................................................23

Figura 25: Representação do ponto médio de um intervalo .....................................................23

Figura 26: Representação da operação soma de matrizes intervalares .....................................25

Figura 27: Representação da operação subtração de matrizes intervalares ..............................25

Figura 28: Representação da operação multiplicação de matrizes intervalares........................26

Figura 29: Representação da operação interseção de matrizes intervalares .............................26

Figura 30: Representação da operação união de matrizes intervalares.....................................27

Figura 31: Diagrama de classes da Biblioteca Intervalar Java .................................................33

xi

Figura 32: Protótipo inicial em rascunho de papel ...................................................................53

Figura 33: Protótipo revisado em rascunho de papel................................................................53

Figura 34: Módulo de operações unárias ..................................................................................55

Figura 35: Módulo de operações binárias.................................................................................56

Figura 36: Módulos de estatísticos ...........................................................................................57

Figura 37: Interface da Calculadora Intervalar I.......................................................................60

Figura 38: Interface da Calculadora Intervalar II .....................................................................61

Figura 39: Interface da Calculadora Intervalar III ....................................................................62

xii

LISTA DE TABELAS

Tabela 1: Resumo dos modos de arrendamento da biblioteca ......................................35

Tabela 2: Descrição dos construtores da classe Interval ................................................36

Tabela 3: Resumo das funcionalidades da classe Interval .............................................37

Tabela 4: Resumo das funcionalidades da classe IntervalElementary .........................38

Tabela 5: Resumo das funcionalidades da classe IntervalSet .......................................38

Tabela 6: Inicialização da classe IntervalMatrix................................................................39

Tabela 7: Resumo das funcionalidades da classe IntervalMatrix ..................................40

Tabela 8: Resumo das funcionalidades da classe IntervalMatrixElementary ..............41

Tabela 9: Resumo das funcionalidades da classe IntervalMatrixSet ............................41

Tabela 10: Resumo das funcionalidades da classe IntervalExpLog .............................42

Tabela 11: Resumo das funcionalidades da classe IntervalTrig ....................................43

Tabela 12: Resumo das funcionalidades da classe IntervalStatistics ...........................45

Tabela 13: Comparação entre resultados obtidos com Java-XSC e IntpakX ..............48

Tabela 14: Valores do consumo de energia elétrica em números reais .......................63

Tabela 15: Indicadores estatísticos reais (resultados são números reais)...................63

Tabela 16: Valores do consumo de energia elétrica em intervalos ...............................64

Tabela 17: Indicadores estatísticos intervalares ...............................................................64

Tabela 18: Valores reais x Valores intervalares................................................................65

1

public class introducao {

private static void main(String args[]) {

double d = 0.0;

for(int i=0; i<10; i++) {

d += 0.1;

}

System.out.println("Resultado = " + d);

} }

1. INTRODUÇÃO

Sistemas computacionais, tanto antigos como os mais recentes, são

incapazes de representar todos os números reais. A representação dos números

reais em computação é realizada através dos números de ponto flutuante [CAMPOS

e FIGUEIREDO, 2005], que provê uma representação binária capaz de armazenar

uma quantidade finita de valores.

Muitos dos avanços das ciências exatas e das engenharias nas últimas

décadas, não seriam possíveis sem o processamento de números de ponto flutuante

pelos computadores digitais. Porém, alguns resultados de computação com pontos

flutuantes parecem estranhos conforme o Exemplo 1 a seguir.

Exemplo 1

Analisando o resultado da execução do trecho de código do Exemplo 1 acima,

escrito em linguagem Java, o resultado esperado deveria ser 10, mas o valor obtido

2

é 0,9999999999999999. Esse resultado apresenta um erro quase desprezível, que,

embora possa parecer insignificante, dependendo do tipo de aplicação, pode gerar

conseqüências catastróficas [FERNANDES et al, 2004].

O erro ocorreu porque no sistema de ponto flutuante da linguagem de

programação Java não existe um número exato que possa representar o número

real calculado durante o processo repetido da operação de soma. Dessa maneira, é

utilizada uma aproximação obtida por arredondamentos para o número de máquina

imediatamente superior (arredondamento para cima) ou inferior (arredondamento

para baixo), ou ainda para o valor mais próximo. No caso do exemplo o

arredondamento foi para baixo.

Uma abordagem para controlar os erros de resultados de computações

numéricas é utilizar a Matemática Intervalar [MOORE, 1979]. A Matemática

Intervalar é uma teoria matemática que propõe solucionar problemas relacionados

às inexatidões e imprecisões que aparecem na computação científica. Dessa

maneira, a utilização de técnicas intervalares é uma alternativa para alcançar limites

garantidos para os resultados de computações.

As linguagens denominadas XSC (Extended Scientific Computation),

conforme citadas em [XSC-LANGUAGES, 2004], têm o objetivo de resolver as

limitações numéricas da máquina fornecendo suporte para computação científica e

verificação automática dos resultados para as operações. Basicamente, bibliotecas

XSC são extensões de linguagens de programação que incorporam a aritmética

intervalar com os arredondamentos. Cronologicamente, as linguagens contempladas

com esta extensão foram: Pascal, Fortran e C++.

Este trabalho tem como objetivos:

3

1. Desenvolver uma biblioteca, denominada Java-XSC, que contemple a

inclusão do tipo Intervalo e das operações sobre esse tipo na linguagem

Java. A biblioteca Java-XSC será estruturada e implementada de forma

modular da seguinte maneira:

Módulo de arredondamento;

Definição do tipo Intervalo;

Definição do tipo Matriz de intervalos;

Operações Aritméticas intervalares;

Operações Lógicas Intervalares;

Operações Trigonométricas Intervalares;

Operações Transcendentais Intervalares;

Operações Estatísticas Intervalares;

Operações Matriciais.

2. Adicionalmente à biblioteca, também será desenvolvida uma ferramenta

visual que permita a utilização das funções aritméticas de maneira amigável

para o usuário. Para isso, será construída uma aplicação similar a uma

calculadora que ilustre as funcionalidades disponíveis da biblioteca Java-

XSC.

Esta dissertação está estruturada como a seguir.

O Capítulo 2, inicialmente, descreve os problemas encontrados nos

computadores devido à representação de ponto flutuante. A seguir, são introduzidas

as operações intervalares necessárias para melhor compreensão deste trabalho.

4

O Capítulo 3 mostra o processo de criação da biblioteca intervalar Java-XSC.

Além disso, também é detalhada a metodologia utilizada para seu desenvolvimento,

bem como o processo inicial de análise e modelagem do projeto, para concluir com

a implementação da biblioteca Java-XSC. Adicionalmente, este capítulo explicita a

construção da interface da calculadora intervalar.

O Capítulo 4 foi construído com o intuito de apresentar um estudo de caso

utilizando a calculadora intervalar. É apresentada uma aplicação de controle

financeiro utilizando a calculadora intervalar para encontrar e comparar indicadores

estatísticos reais com indicadores estatísticos intervalares.

Finalmente, o Capítulo 5 apresenta as conclusões obtidas com este trabalho,

bem como explicita trabalhos futuros que podem ser realizados com esta primeira

versão da biblioteca intervalar Java-XSC desenvolvida no Centro de Informática da

Universidade Federal de Pernambuco.1

1 Java-XSC: Java para Computação Científica com Controle Automático do Erro. http://www.cin.ufpe.br\~mac\probint

http://www.cin.ufpe.br~macprobint

5

2. FUNDAMENTOS

O computador pode ser definido como uma máquina digital, utilizada também

para realizar cálculos, que tem como unidade fundamental de processamento o bit.

Os bits que constituem as informações da memória do computador são utilizados

para representar diversas letras do alfabeto, números inteiros, imagens, vídeos,

sons, aplicações comerciais, entre outros diversos tipos de informações.

Todos os elementos acima citados apresentam como característica comum e

principal o fato de poderem ser finitamente representados, ou seja, o computador

possui uma maneira exata para representá-los a partir de uma determinada

codificação. Os problemas para os computadores começam a surgir quando é

necessário operar com números reais, os quais são representados

computacionalmente pelos números de ponto flutuante.

A utilização de intervalos permite diminuir e controlar a perda de exatidão

depois de repetidos cálculos numéricos com números de ponto flutuante. Através da

aritmética intervalar [MOORE, 1979], os números reais podem ser representados na

forma de intervalos, e então passam a ser manipulados como tal, aproveitando todos

os benefícios que esta representação pode proporcionar: exatidão numérica dos

cálculos efetuados com verificação automática dos resultados.

A subseção a seguir apresenta o conceito da representação de ponto

flutuante, e posteriormente, as detalhes de sua implementação na linguagem Java.

6

2.1 REPRESENTAÇÃO DOS REAIS NOS COMPUTADORES

No início da história dos computadores a representação numérica dos

números reais era realizada através do sistema numérico de ponto fixo. Porém,

como os resultados das operações aritméticas apresentavam muitas discrepâncias e

erros, a representação desses evoluiu para o sistema de ponto flutuante.

Nesta seção será mostrado como os números reais são representados nos

computadores através da representação de ponto flutuante, o porquê dessa

representação (a partir dos erros numéricos) e exemplos de propriedades algébricas

dos reais que são perdidas com essa representação [CAMPOS e FIGUEIREDO,

2005].

2.1.1 ERROS NUMÉRICOS

Os erros numéricos mais comumente citados são:

Inerente. Se o problema é calcular a área de um círculo de raio 6, na

fórmula c = r2, deve ser representado por um número. A questão é que

o conjunto de números disponíveis em qualquer computador é finito, assim

como é finita a excursão de qualquer elemento deste conjunto. Em outras

palavras, no modelo da matemática, o conjunto dos números reais, longe

está de ser representável e operável por qualquer computador. Portanto,

expressões como para todo x real... , não têm sentido em computações

que exigem um processamento numérico automático, incluindo desde os

calculadores que realizam operações básicas, aos computadores dos

centros científicos.

7

Truncamento. Como calcular

0

/1n

n ? Não sendo possível realizar tal

feito, a ação tomada é truncar a expressão acima, ou seja, limitar sua

operação para um valor possível de cálculo.

Arredondamento. Este erro está associado ao tamanho da palavra da

máquina.

Por fim, além dos erros citados acima, o processamento numérico nos

computadores é realizado na base 2, Figura 1, portanto, adicionalmente ainda têm-

se os erros de conversão de base.

Figura 1: Seqüência de passos para processamento numérico

O conjunto dos números reais é um corpo ordenado completo. O fato dos

reais constituírem um corpo possibilita que nele sejam resolvidas equações do tipo

ax = b, a 0, onde a solução única é x = a-1b. Como é completo, equações do tipo x2

= 2 têm solução. Por razões de ordem prática, os computadores, em geral,

representam constantes de bits.

No caso dos reais é necessário substituí-los por outro conjunto que os

represente, usualmente o dos números de ponto flutuante. O problema, porém é que

Usuário digita números na base 10

Base 10

Base 2

Base 2

Base 10

Cálculos realizados na base 2

Usuário recebe resultados na base 10

8

o conjunto dos números de ponto flutuante, diferentemente dos reais, não tem

propriedades algébricas que garantam os resultados dos cálculos efetuados. Por

exemplo, a soma de dois números de grande magnitude pode gerar overflow, ou

seja, nem sempre a soma de dois números de ponto flutuante é um número

flutuante.

2.1.2 SISTEMA DE PONTO FLUTUANTE

Um número de ponto flutuante, x, é da fórmula:

x = m x be = d1.d2...dl x be,

Figura 2: Representação de número de ponto flutuante

onde, m é uma mantissa de comprimento l, b é a base, a qual é um inteiro maior ou

igual a 2, e e o expoente, tal que emin e emax são números inteiros. Os dígitos da

mantissa são restritos a 1 d1 b -1 e 0 dk b -1, k =2, ···, n. Porque d1 0, x é

denominado um número de ponto flutuante normalizado. Um sistema de ponto

flutuante, F, é usualmente representado por:

F = F (b, l, emin, emax)

Figura 3: Representação do sistema de ponto flutuante

9

A representação do zero real, dos elementos de menor e maior valor

absoluto, xmin e xmax, e o número de elementos de F, são representados

respectivamente através da Figuras 4, 5 e 6, a seguir.

0 = + 0.000 0 x b

Figura 4: Representação do zero real em F

xmin = + 0.10 0 x b ,

xmax = + 0.(b-1)(b-1)...(b-1) x b

Figura 5: Representação do mínimo e máximo em F

#F = 2(b-1)bl -1(emax emin + 1) + 1

Figura 6: Número de elementos de F

O termo número de ponto flutuante deve-se ao fato de que o ponto se move

no número dependendo do expoente da base. Alguns autores usam vírgula ao invés

do ponto; neste trabalho adotou-se o ponto que é a notação usada nas máquinas

digitais.

emin

e min

e max

10

Seja o sistema de ponto flutuante F = F(2, 3, -1, 2). Portanto F

tem base binária, mantissa de 3 dígitos, o menor expoente é

emin = -1 e o maior expoente emax = 2, assim a excursão do

expoente vai de -1 a 2 e todos os expoentes deste sistema são

{-1,0,1,2}, isto é, tem-se um total de 4 expoentes, que vem do

cálculo emax

emin + 1. Para este sistema tem-se:

Representação do zero: 0 = + 0.000 x 2-1;

Maior elemento de F: xmax = + 0.111 x 22;

Menor elemento de F: -xmax = - 0.111 x 22;

Menor elemento positivo de F: xmin = + 0.100 x 2-1;

Maior elemento negativo de F: -xmin= - 0.100 x 2-1;

Número de elementos de F: #F = 33.

Exemplo 2

O subconjunto dos números reais, R, que é representável em F são os

números não - igualmente espaçados localizados na região hachuriada mais o zero

na Figura 7 a seguir.

Figura 7: Distribuição dos números reais na reta

0 -xmax -xmin xmin xmax

regiões de underflow

região de overflow

11

Sejam F = F (10, 4, -9, 9),

a = 0.3245 x 102,

b = 0.4587 x 10-3,

c = 0.8764 x 10-4.

Colocando os números na potência do maior expoente,

a = 0.3245 x 102,

b = 0.00004587 x 102,

c = 0.000008764 x 102.

Somando,

a + b = 0.32454587 x 102,

a + c = 0.324508794 x 102.

Arredondando porque l = 4,

a + b = 0.3245 x 102,

a + c = 0.3245 x 102.

Portanto, tem-se que a + b = a + c, mas b c!

Além da restrição com respeito ao número de elementos, uma vez que R é

não-enumerável e F é finito, propriedades algébricas que são válidas em R não são

válidas em F. O Exemplo 3 a seguir mostra a falha na lei do corte aditiva que

consiste na seguinte afirmação:

a, b, c R, a + b = a + c b = c.

Será mostrado que em F,

a, b, c

F, tais que a + b = a + c b = c.

Exemplo 3

12

public class exemplo1 {

private static void main(String args[]) {

double d = 3.9-3.8;

if(d==0.1) {

System.out.println("igual");

} else {

System.out.println("diferente");

} }

}

2.2 PONTO FLUTUANTE EM JAVA

Para entender a importância da calculadora intervalar proposta neste

trabalho, a seguir são exibidos problemas decorrentes da implementação do ponto

flutuante em Java. A linguagem Java oferece os seguintes elementos para

representação de ponto flutuante:

Primitiva Float;

Primitiva Double;

Wraped Classes

Float / Double do pacote Java.lang [SUN

MICROSYSTEMS, 2005].

A seguir, nos Exemplos 4 e 5, estão erros em operações de ponto flutuante

obtidos a partir da execução de um código fonte em Java:

Exemplo 4

13

public class exemplo2 {

public static void main(String args[]) {

double d = 0.0;

for(int i = 0; i < 10; i++){

d += 0.4;

}

System.out.println(d); }

}

A resposta para Exemplo 4 deveria ser a literal igual, mas executando-se o

programa Java acima, obtém-se como resposta diferente , devido à operação

resultar o valor 0.10000000000000009.

O Exemplo 5, a seguir, consiste na execução seqüencial de dez operações de

adição do valor 0.4 para uma posterior exibição da resposta através da saída padrão

de Java. Após executar o laço computacional por dez vezes o resultado esperado da

operação do código do Exemplo 5 deveria ser 4.0, mas o resultado obtido é

3.9999999999999996.

Exemplo 5

Esses fatos ocorrem porque a implementação da representação de ponto

flutuante na linguagem Java incorpora de maneira parcial o padrão IEEE Standard

for Binary Floating-Point Arithmetic, ANSI/IEEE Standard 754-1985 de aritmética de

ponto flutuante [MACAULAY INSTITUTE, 2004]. Os tipos primitivos float e double da

linguagem representam a precisão simples (32 bits) e a precisão dupla (64 bits),

14

respectivamente, seguindo parcialmente o padrão. A seguir estão duas figuras que

ilustram a representação das primitivas da linguagem Java.

1 bit 8 bits 23 bits

sign exponent

significand

Figura 8: Representação da primitiva float

1 bit 11 bits 52 bits

sign exponent

significand

Figura 9: Representação da primitiva double

A representação através da primitiva float oferece de seis a nove dígitos de

precisão, enquanto que a representação double da entre quinze e dezessete dígitos

de precisão [GOSLING, 1996].

Java requer que os resultados nas operações de ponto flutuante sejam

arredondados para o número mais exato que a máquina consiga representar. Para

resultados inexatos a resposta deve ser aproximada para o valor mais próximo

representável. Esta é mais uma definição do padrão 754 IEEE conhecida como

round to nereast [GOSLING, 1996].

Operações entre números de ponto flutuante em Java podem produzir

exceções, que são tratadas da seguinte maneira:

Operações que produzem overflow como resultado, apresentam uma

representação de infinito como resposta;

Operações que produzem underflow como resultado, apresentam o

valor zero como resposta;

15

Operações que geram resultados matemáticos não definidos produzem

como resposta a notação NaN (Not a Number).

Uma vez que apresentamos problemas da representação de números de

ponto flutuante na linguagem Java e detalhamos sua representação e seus

propósitos, vamos agora apresentar as discordância e inadequações dessa

implementação com o padrão internacionalmente reconhecido ANSI/IEEE Standard

754-1985. A implementação de ponto flutuante em Java falha nos seguintes

aspectos em relação ao padrão IEEE [MACAULAY INSTITUTE, 2004]:

Ausência de suporte às seguintes flags de exceções:

o Operação inválida;

o Overflow;

o Underflow;

o Divisão por zero;

o Resultados inexatos;

Não implementação dos arredondamentos direcionados;

Não oferecimento de suporte para os seguintes tipos de dados próprios

para aritmética intervalar de máquina:

o Tipo intervalo;

o Tipos complexos;

o Operações aritméticas intervalares;

o Matrizes intervalares;

o Operações matriciais intervalares;

16

Como mostrado acima, embora existam evoluções na representação

numéricas para os computadores, os problemas das operações computacionais não

foram completamente resolvidos. Mesmo com o surgimento da padronização da

representação de ponto flutuante, que podemos eleger como a primeira solução

para problema de exatidão e precisão de máquina, os erros de computação não

estavam descartados de maneira satisfatória.

Como a representação numérica de ponto flutuante não conseguiu de

maneira satisfatória minimizar esses problemas para programas de computação

científica, surgiu a proposta de incluir a matemática intervalar como auxílio às

linguagens de computador. Dessa maneira, pelo menos era possível garantir a

incerteza das respostas. A definição e os propósitos da aritmética intervalar são

descritos na próxima seção deste documento para mostrar ao leitor como este novo

tipo de informação contribui para a garantia e exatidão de rotinas computacionais

científicas.

2.3 MATEMÁTICA INTERVALAR

As primeiras pesquisas e trabalhos na área da matemática computacional

intervalar foram desenvolvidos por Moore [MOORE, 1979] que propôs a utilização de

intervalos numéricos para operar entre si. Assim, os problemas de aproximação

passaram a ser contornados, pois a resposta das operações seria agora um

intervalo que conteria o resultado esperado, caso este não pudesse ser

representado de forma exata pela máquina. O passo seguinte foi incorporar os

17

intervalos e sua aritmética, bem como os princípios da aritmética de exatidão

máxima [KULISCH, 1983], às linguagens de programação.

A utilização de intervalos para expressar resultados permite controlar a perda

de exatidão depois de repetidos cálculos numéricos computacionais. Através da

aritmética intervalar, os números reais podem ser representados na forma de

intervalos, e então passam a ser manipulados como tal, aproveitando todos os

benefícios que esta representação pode proporcionar, seja na exatidão numérica

dos cálculos efetuados ou nas linguagens com verificação automática dos resultados

Esta abordagem define um intervalo como sendo uma aproximação de todos

os números reais pertencentes a ele, ou seja, se a representação de um intervalo for

[i1, i2], então todos os números reais entre i1 e i2, inclusive, farão parte deste

intervalo, abstraindo dessa maneira a representação numérica limitada da máquina.

Concluindo, a aritmética intervalar trata da representação numérica através de

intervalos e das operações neles realizadas. A seguir serão detalhadas as principais

definições, bem como as operações de maior destaque. Esta subseção visa

ambientar os leitores no universo da Aritmética Intervalar, para um melhor

entendimento e compressão do restante do documento de dissertação.

2.3.1 INTERVALO DE NÚMEROS REAIS

Um intervalo de números reais, R, é da forma

I = [x1, x2],

18

onde, x1 e x2 pertencem ao conjunto dos números reais, tal que x1 x2. São

exemplos de intervalos: [1,2], [-2,-1], [1.9, 4.8], [1,1].

2.3.2 CONJUNTO DE INTERVALOS

O conjunto de todos os intervalos de reais pode ser definido da seguinte

forma:

IR = { [x1, x2] | x1, x2

R , x1

x2}.

Figura 10: Representação matemática do conjunto de intervalos

Associando-se a cada intervalo [x1, x2]

IR um ponto (x1, x2)

R2, obtemos

uma representação geométrica para IR, conforme a Figura 11 a seguir:

Figura 11: Representação gráfica do espaço dos Intervalos

R

[x1, x2]

0

x1 = x2

19

Importante ressaltar que todo e qualquer número real x

R pode ser visto

como um intervalo de IR. Basta identificar os pontos x

R com os intervalos

pontuais X = [x, x]

IR. Estes intervalos também são chamados de intervalos

degenerados, porém a nomenclatura de intervalo pontual é comumente utilizada. A

Figura 12 abaixo representa a hierarquia numérica dos conjuntos, onde N é o

conjunto dos números naturais, Z, dos inteiros, Q, dos racionais, R, dos reais e IR

dos intervalos.

Figura 12: Estrutura hierárquica da representação numérica

2.3.3 OPERAÇÕES ARITMÉTICAS

Nesta subseção serão exibidas as definições das operações intervalares

[MOORE, 1979]. Considerando os intervalos A = [a1, a2] e B = [b1,b2], a definição das

operações aritméticas entre intervalos pode ser generalizada através da fórmula a

seguir:

20

A * B = {a * b | a A, b

B}, * {+, -, *, / }.

Figura 13: Representação das operações básicas intervalares

2.3.3.1 SOMA INTERVALAR

A + B = [ (a1 + b1 ) , ( a2 + b2 ) ].

Figura 14: Representação da operação intervalar de soma

2.3.3.2 PSEUDO INVERSO ADITIVO INTERVALAR

-A = [-a2 ,- a1].

Figura 15: Representação da operação seudo pnverso aditivo intervalar

2.3.3.3 SUBTRAÇÃO INTERVALAR

A - B = A + (-B) = [ (a1 - b2 ) , ( a2 - b1 ) ].

Figura 16: Representação da operação intervalar de subtração

2.3.3.4 MULTIPLICAÇÃO INTERVALAR

A x B = [ mim { a1.b1,a1.b2,a2.b1.,a2.b2} , max{ a1.b1,a1.b2,a2.b1.,a2.b2} ].

Figura 17: Representação da operação intervalar de multiplicação

21

2.3.3.5 PSEUDO INVERSO MULTIPLICATIVO INTERVALAR

A-1 = 1/A = [1 / a2 ,1 / a1], 0 A.

Figura 18: Representação da operação intervalar de pseudo inverso multiplicativo

2.3.3.6 DIVISÃO INTERVALAR,

A / B= [ min{a1/b1,a1/b2,a2/b1,a2/b2 } , max{ a1/b1,a1/b2,a2/b1,a2/b2 ].

Figura 19: Representação da operação intervalar de divisão

2.3.4 OPERAÇÕES ENTRE CONJUNTOS

Nesta subseção serão exibidas as funções envolvendo conjuntos de

intervalos.

2.3.4.1 INTERSEÇÃO DE INTERVALOS

Se max {a1, b1} min {a2, b2}, então

A B = [ max {a1, b1} , min {a2, b2} ].

Caso min {a2, b2} < max {a1, b1} então

A B = Ø.

Figura 20: Representação da operação intervalar de interseção

22

2.3.4.2 UNIÃO DE INTERVALOS

A

B = [ min {a1, b1} , max {a2, b2} ], A

Ø.

Figura 21: Representação da operação intervalar de união

2.3.4.3 UNIÃO CONVEXA DE INTERVALOS

A

B = [ min {a1, b1} , max {a2, b2} ].

Figura 22: Representação da operação intervalar de união convexa

Um ponto importante é que ao contrário da operação de união, em operações

de união convexa, a intersecção entre intervalos é permitida ser vazia.

2.3.5 OUTRAS OPERAÇÕES

2.3.5.1 DISTÂNCIA ENTRE INTERVALOS

d = max{|a1 b1|, |a2 b2|}.

Figura 23: Representação da distância intervalar

23

2.3.5.2 DIÂMETRO DE UM INTERVALO

w = a2 a1.

Figura 24: Representação do diâmetro de um intervalo

2.3.5.3 PONTO MÉDIO DE UM INTERVALO

Seja A = [a1, a2] um intervalo pertencente ao intervalo dos números reais. O

ponto médio deste intervalo define-se como sendo a média aritmética dos seus

valores extremos.

m = (a1 + a2) / 2.

Figura 25: Representação do ponto médio de um intervalo

Para ilustrar as definições anteriormente mostradas, o Exemplo 6 a seguir

considera intervalos A = [0,10], B = [-3, 6] e C = [1, 3]. Então:

24

Sejam os seguintes intervalos A = [0,10], B = [-3, 6] e C = [1, 3]. Então:

A + B = [0, 10] + [-3, 6] = [-3, 16].

A - B = [0, 10] + ( - [-3, 6] ) = [0, 10] + [-6, 3] = [-6, 13].

A x B = [0, 10] X [-3, 6]

= [min {0 X -3, 0 X 6, 10 x -3, 10 X 6}, max {0 X -3, 0 X 6, 10 x -3, 10 X 6}] = [0, 60].

A / B = [0, 10] / [-3, 6]

= [ min {0 / -3, 0 / 6, 10 / -3, 10 / 6}, max {0 / -3, 0 / 6, 10 / -3, 10 / 6}] = [0, 10/6].

C-1 = [1/3, 1].

A B = [0, 10] [-3, 6] = [ max (0, -3), min (10, 6) ] = [ 0, 6].

A B = [0, 10] [-3, 6] = [ min (0, -3), max (10, 6) ] = [-3, 10].

d(A, B) = max { | 0 (-3)| , |10 - 6| } = max (3, 4) = 4

d(A, C) = max { | 0 1 | , |10 - 3| } = max (1, 7) = 7

d(B, C) = max { | 3 1| , | 6 - 3| } = max (4, 3) = 4

w(A) = w (10 0 ) = 10

w(B) = w ( 6 (-3) ) = 9

w(C) = w ( 3 1) = 2

m(A) = m ((10 + 0) / 2) = 5

m(A) = m (( 6 + (-3)) / 2) = 1.5

m(A) = m (( 3 + 1) / 2) = 2

Exemplo 6

25

2.3.7 OPERAÇÕES MATRICIAIS

Dizemos que A = Aij é uma matriz intervalar de ordem m por n, se A for uma

matriz com m linhas e n colunas, onde cada elemento Aij é um intervalo. Exemplo:

1,1][1], [1

1] 0, [,1] [1 A

4]6,[2] 2, [

4] 3, [1,2][ B

2.3.7.1 SOMA DE MATRIZES INTERVALARES

Sejam A = Aij e B = Bij duas matrizes intervalares de mesma ordem. A

matriz soma é definida como sendo a matriz S = A + B com elementos para todos

os índices i, j.

,ijijij BS

Figura 26: Representação da operação soma de matrizes intervalares

2.3.7.2 SUBTRAÇÃO DE MATRIZES INTERVALARES

A matriz diferença entre as matrizes A e B é definida como sendo a matriz

D = A - B, com elementos Dij = Aij - Bij, para todos índices i, j.

,ijijij BAD

Figura 27: Representação da operação subtração de matrizes intervalares

26

2.3.7.3 MULTIPLICAÇÃO DE MATRIZES INTERVALARES

Sejam A uma matriz intervalar de ordem m por p e B uma matriz intervalar de

ordem p por n. A operação de multiplicação é definida como sendo a matriz

intervalar M = A.B, de ordem m por n, cujos elementos são obtidos através da

fórmula abaixo:

p

1kikij kjBAM

Figura 28: Representação da operação multiplicação de matrizes intervalares

2.3.7.4 INTERSEÇÃO DE MATRIZES INTERVALARES

Sejam A e B matrizes intervalares de mesma ordem. A operação de

interseção é definida através da matriz I = A

B, cujos elementos são:

,ijijij BAI

Figura 29: Representação da operação interseção de matrizes intervalares

para todos os índices i, j. Caso exista alguma situação onde os índices i, j tal que

Aij Bij = , não existirá a intersecção das matrizes.

27

4]- [-6, [-1,1] 2] 2,[ 1] [1,

4] 3,[ 0,1][ 2] [-1, 1] , [1BA =

3]- 7,-[ 3] [3,

5] 3,[ 3] [0,

4]- [-6,- [-1,1] 2] 2,[ 1] [1,

4] 3,[ - 0,1][ 2] [-1, 1] , [1BA =

7] 3,[ 1]- [-1,

2]- 4,-[ 0] [-1,

4]- 6,-[ 1,1]-[ 4] [3, 1] , [1 2] [2, [-1,1] 2] [-1, 1] [1,

4]- 6,-[ 0,1][ 4] [3, 1] , [1 2] 2,[ 0,1][ 2] [-1, 1] , [1BA =

10] 3,-[ 4] [-3,

4] 3,-[ 4] [-1,

4]- [-6, [-1,1] 2] 2,[ 1] [1,

4] 3,[ 0,1][ 2] [-1, 1] , [1BA =

1] [1,=

4]- [-6, [-1,1] 2] 2,[ 1] [1,

4] 3,[ 0,1][ 2] [-1, 1] , [1BA =

1] [1,=

2.3.7.5 UNIÃO DE MATRIZES INTERVALARES

Sejam A e B duas matrizes intervalares de mesma ordem. A operação de

união é a matriz U = A

B, cujos elementos são para todos os índices i, j.

,ijijij BAU

Figura 30: Representação da operação união de matrizes intervalares

Caso exista um par de índices i, j tal que Aij

Bij = , então não existirá a união das

matrizes.

Exemplo 7

28

2.4 CONSIDERAÇÕES FINAIS

No próximo capítulo deste trabalho será apresentada a contribuição principal

desta dissertação de mestrado, que consiste em desenvolver uma biblioteca

intervalar para a linguagem de programação Java. Esta biblioteca contém a

implementação dos tipos intervalo e matriz de intervalos e de suas operações

conforme apresentadas nesta seção.

Como todas as outras linguagens, Java não está livre dos erros

computacionais detalhados nas seções anteriores, então a construção desta

biblioteca têm como objetivo levar mais robustez para a linguagem e oferecer

mecanismos que permitam a construção de diversas aplicações voltadas para a

matemática computacional.

29

3. JAVA-XSC

Concebida na década de 90, a linguagem de programação Java alcançou

enorme popularidade desde o início de sua utilização. Sua rápida ascensão e

grande aceitação devem-se, principalmente, às propriedades do paradigma de

orientação a objeto, particularmente, o fato de ser portável. Ou seja, as aplicações

desenvolvidas na linguagem Java podem ser executadas em diferentes tipos de

plataformas e arquiteturas.

Uma sucinta e boa definição para a linguagem Java pode ser encontrada em

um artigo próprio de sua empresa criadora e mantenedora, a Sun Microsystems, que

a define da seguinte maneira: Java é simples, orientada a objeto, distribuída,

interpretada, robusta, segura, neutra de arquitetura, portável, multi-thread e dinâmica

[CHOUDHARI, 2001].

Outras características que fazem de Java uma linguagem de alto nível de

abstração e de fácil manipulação pelos programadores são o suporte a herança

entre os objetos, abolição do uso de ponteiros, alocação dinâmica de memória e, por

fim, utilização do processo interno de garbage collector com a finalidade de

desalocação automática de memória.

Embora apresente todas as vantagens acima citadas, Java apresenta falhas

na sua implementação que comprometem aplicações de caráter matematicamente

computacional. Conforme apresentado nas anteriormente, a implementação parcial

do padrão ANSI/IEEE Standard 754-1985 referente à representação de ponto

flutuante, inviabiliza o desenvolvimento de aplicações matemáticas que necessitem

de alta exatidão nos resultados. Exatamente neste ponto é que entra a contribuição

30

deste trabalho em propor a inclusão de uma biblioteca intervalar para a linguagem

Java de modo que esta passe a oferecer suporte à matemática computacional.

Esta biblioteca conterá a definição de novos tipos de dados, entre eles o tipo

Intervalo e o tipo Matriz de Intervalos, e fará uso dos conceitos da Matemática

Intervalar [MOORE, 1979] na definição das operações entre esses novos tipos. Este

capítulo está dividido em duas partes. Inicialmente será detalhado o processo de

elaboração, implementação e documentação da biblioteca, e por fim será

apresentada uma aplicação gráfica, a calculadora intervalar, para utilização de

maneira mais fácil e intuitiva das funcionalidades da biblioteca desenvolvida.

3.1 BIBLIOTECA INTERVALAR JAVA

A Aritmética Intervalar proporciona fielmente estimativas de erros. Desde que

valores intermediários frequentemente em uma computação dependem dos outros, a

estimativa final obtida sem aritmética intervalar tende a ser pessimista. Contudo, o

prospecto para uso efetivo da aritmética intervalar parece muito bom, logo esforços

devem ser feitos para incrementar sua disponibilidade [KNUTH, 1997]. O

desenvolvimento de uma biblioteca Intervalar em Java é exatamente uma maneira

de popularizar o uso da aritmética intervalar, de maneira transparente para as

pessoas que a utilizarão.

Considerando essa contribuição, surgiu a motivação para a construção de

uma API (Application Programing Interface) para a linguagem Java que fornecesse

implementação de arredondamentos direcionados e definição do tipo Intervalo,

matriz de intervalos e suas operações aritméticas, lógicas, trigonométricas,

transcendentais e estatísticas.

31

Ao contrário de aproximar um número real por uma representação de ponto

flutuante da máquina, a proposta é aproximá-lo para um intervalo que contenha esse

número tal que seu limite superior e inferior possam ser representados por números

de ponto flutuante. Dessa maneira, cálculos serão feitos usando intervalos como

operandos e operações aritméticas são substituídas por operações intervalares, que

oferecem garantias e precisão nos resultados. [MOORE, 1996].

3.1.1 ANÁLISE E MODELAGEM DA API

Inicialmente foi feito um levantamento de quais tipos e funções precisariam

ser desenvolvidas para construção da biblioteca Intervalar Java. Esta pesquisa

baseou-se em verificar quais os complementos oferecidos por outras linguagens de

programação que oferecem suporte à matemática computacional, como as

linguagens Cobol, Pascal e C.

Basicamente, para as linguagens acima citadas foram desenvolvidas

extensões, denominadas Extended Scientific Computing (XSC) [XSC-LANGUAGES,

2004] com intuito de acoplar suporte para computação científica, baseadas nos

princípios definidos na aritmética intervalar. Como característica comum, as

linguagens XSC apresentam as seguintes propriedades:

Conceito de Overloading;

Controle de Truncamento;

Controle de Arredondamento;

Tipos de dados aritméticos pré-definidos (tipo intervalo, tipo complexo

e seus correspondentes em vetores e matrizes);

32

Operadores aritméticos pré-definidos com alta precisão para os tipos

aritméticos;

Funções elementares para os tipos aritméticos com alta precisão;

Então, a partir desta pesquisa, vimos a necessidade de evoluir a

implementação da biblioteca em módulos para contemplar os pontos apresentados.

Detalhes da implementação dos módulos estão descritos nas próximas subseções

deste documento.

Antes da implementação propriamente dita, foi realizado um trabalho de

estruturação e organização da biblioteca para evitar erros futuros de programação.

Para isso, o projeto de implementação da biblioteca foi modelado através da

ferramenta JUDE UML Modeling Tools [JUDE, 2006], através da construção do

diagrama de classe que constitui o passo inicial do projeto e que está ilustrado na

Figura 31 a seguir.

33

Figura 31: Diagrama de classes da Biblioteca Intervalar Java

34

Dessa forma foi possível abstrair passos do projeto de implementação e

detalhar de maneira superficial os atributos e métodos que devam ser contemplados

durante a fase de desenvolvimento. A modelagem feita realça que a classe

Interval será o ponto focal da biblioteca e que será referência, e servirá como

dependência, para quase todas as outras classes implementadas no projeto.

Importante salientar que a decisão de projeto de definir os métodos das

classes do sistema com o modificador static foi para evitar a necessidade de

sempre se instanciar objetos para realizar cálculos e utilizar memória

desnecessariamente [DEITEL, 2001]. Com os métodos definidos dessa maneira, as

operações da biblioteca estarão disponíveis em qualquer ponto das mais diversas

aplicações, sendo bastante apenas solicitar os métodos e passar os parâmetros

desejados para cálculo da operação.

Como ferramenta de desenvolvimento foi utilizado o ambiente de

desenvolvimento Integrado Eclipse [ECLIPSE, 2005], disponível a Web, onde foi

utilizada a versão 3.0.1 do software. A versão da máquina virtual Java utilizada para

geração do código intermediário foi a versão 1.4 fornecida pela Sun Microsystens

[SUN MICROSYSTENS, 2005], através do pacote j2sdk1.4.2_04 também disponível

na Web.

3.1.2 IMPLEMENTAÇÃO

A implementação da biblioteca foi incremental e dividida em módulos, devido

ao elevado grau de acoplamento entre as classes desenvolvidas (vide diagrama de

classes da seção anterior, Figura 31). Estruturalmente, os módulos fazem parte de

35

um mesmo pacote da linguagem Java. Esta subseção apresentará cada um desses

módulos na ordem em que foram desenvolvidos e detalhes de sua implementação.

3.1.2.1 MÓDULO DE ARREDONDAMENTOS

Antes da implementação da classe fundamental da biblioteca, viu-se a

necessidade de desenvolver um mecanismo para oferecer o controle de

arrendondamentos das futuras operações. Além disso, as bibliotecas intervalares

das linguagens de programação têm como uma de suas característica o suporte a

aproximações.

Após estudos sobre funcionamento dos arredondamentos direcionados para

cima e para baixo foi implementada a classe IntervalRounding que seria

responsável por realizar as aproximações das operações. A classe fornece dois

métodos que oferecem arredondamento para cima e para baixo, e que recebem

como parâmetros o número a ser aproximado e a precisão de arredondamento

através da quantidade de casas decimais.

A seguir está a assinatura dos métodos definidos nesta classe e que

correspondem ao arredondamento para cima e para baixo, respectivamente:

Tabela 1: Resumo dos modos de arrendamento da biblioteca

Função / Assinatura do Método Descrição

public static double roundUp(double d,

int dec)

Arredonda o número para cima

public static double roundDown(double

d, int dec)

Arredonda o número para baixo

36

3.1.2.2 MÓDULO INTERVALAR

Cronologicamente, após a criação do módulo de arredondamentos, foi

discutido o modo de implementação do tipo Intervalo. A primeira sugestão foi

modificar os tipos primitivos da linguagem para acrescentar um novo tipo aos já

existentes int, float, double e boolean [SUN MICROSYSTENS, 2005].

Mas por limitações técnicas e por questões legais em alterar o código fonte da

máquina virtual Java, a primeira opção de implementação não foi levada adiante.

A segunda alternativa sugerida foi utilizar um dos elementos primitivos da

linguagem para desenvolver o novo tipo de dado. E, assim, foi feito através da

utilização da primitiva double para definir os limites inferior e superior da classe

Interval, que representa o tipo Intervalo na biblioteca Intervalar. A classe

Interval foi então implementada apresentando a opção de possuir dois

construtores que podem receber os limites e a precisão, ou a opção de receber um

número real e transformá-lo em um objeto intervalo através da precisão

parametrizada. A seguir está a assinatura dos construtores citados:

Tabela 2: Descrição dos construtores da classe

Interval


public Interval(double

lowerBound, double upperBound,

int precision)

Construtor com os limites inferior e superior, e

indicador de precisão do intervalo

public Interval(double arg0, int

precision)

Construtor que gera um intervalo que contém

o número parametrizado

37

A implementação da classe Interval também contemplou métodos que

podem ser considerados funções unárias sobre intervalos e definidas formalmente

na Aritmética Intervalar de Moore [DUTRA, Enéas, 2000]. A Tabela 3 a seguir traz

um resumo das funcionalidades extras da classe Interval.

Tabela 3: Resumo das funcionalidades da classe

Interval


public double width() Retorna o comprimento de um intervalo.

public boolean isEmpty() Verifica se um intervalo é vazio. Retorna

verdadeiro para intervalos degenerados.

public boolean pertains(double

arg0)

Verifica se um número qualquer pertence a um

intervalo.

public Interval symmetric() Retorna o intervalo simétrico a um intervalo.

public Interval reciprocal() Retorna o intervalo recíproco a um outro

intervalo.

public boolean equals(Interval

arg0)

Verifica se um intervalo é igual a outro

intervalo de acordo com a aritmética de

Moore.

Uma vez definido o tipo Intervalo, o próximo passo foi fazer um levantamento

das funções intervalares aplicadas a esse tipo e desenvolvê-las. As funcionalidades

foram então categorizadas de acordo com sua natureza em dois tipos: funções

elementares e funções lógicas de conjunto. Para cada grupo foi criada uma nova

classe para agrupar as funcionalidades correspondentes, que receberam os

seguintes nomes, respectivamente: IntervalElementary e IntervalSet.

A classe IntervalElementary implementa as operações aritméticas para o

tipo intervalo, além da operação de raiz quadrada e a classe IntervalSet

caracterizou-se por reunir os métodos relacionados a lógica de conjuntos para o tipo

Intervalo. As assinaturas dos métodos e uma breve descrição estão nas Tabelas 4 e

5 a seguir:

38


IntervalElementary


public static Interval add(Interval arg0,

Interval arg1)

Retorna intervalo com a soma de

dois intervalos parametrizados.

public static Interval sub(Interval arg0,

Interval arg1)

Retorna intervalo com subtração

de dois intervalos

parametrizados.

public static Interval mult(Interval

arg0, Interval arg1)

Retorna intervalo com

multiplicação de dois intervalos

parametrizados.

public static Interval div(Interval arg0,

Interval arg1)

Retorna intervalo com divisão de


public static Interval sqrt(Interval

arg0)

Retorna intervalo com resultado

de raiz quadrada para os limites

do intervalo parametrizado.


IntervalSet


public static Interval

interscetion(Interval arg0, Interval arg1)

Retorna intervalo com

interseção de dois intervalos

parametrizados.

public static Interval union(Interval

arg0, Interval arg1)

Retorna intervalo com união de


public static boolean isIn(Interval arg0,

Interval arg1)

Retorna sinalização se um

intervalo está contido em outro

parametrizado.

39

3.1.2.3 MÓDULO MATRICIAL

Uma importante contribuição da biblioteca foi o desenvolvimento de um

módulo com matrizes de intervalos para permitir a resolução de sistemas de

equações lineares intervalares, por exemplo. Com base na implementação dos

módulos de arredondamentos e de intervalos, viu-se a possibilidade de expandir a

biblioteca com a inclusão de um novo tipo denominado IntervalMatrix que

representa uma matriz de intervalos.

Através da propriedade de reuso possibilitada pela linguagem Java, foi

utilizada como base da classe IntervalMatrix, a classe Interval e suas

operações. Para construir uma matriz de intervalos a classe recebe inicialmente um

construtor que indica as dimensões da matriz, e posteriormente é fornecido um

método para preencher cada posição da matriz definida com um intervalo arbitrário.

As assinaturas desses métodos estão detalhados na Tabela 6:

Tabela 6: Inicialização da classe

IntervalMatrix


public IntervalMAtrix(int dim1, int dim2) Construtor que recebe dimensões

da matriz de intervalos.

public void putIntervaltAt(int line, int

column, Interval interval)

Método que coloca intervalos em

cada posição da matriz criada.

Dessa maneira a classe torna-se genérica o suficiente para construir matrizes

de ordem n, inicialmente com todos os intervalos da forma [0,0]. Os valores podem

ser preenchidos ou alterados sob demanda, de acordo com a necessidade da

aplicação. Complementando a classe IntervalMatrix foram desenvolvidos

40

métodos elementares de matrizes para tratar algumas de suas propriedades, como,

por exemplo verificar se a matriz é nula, se a matriz pode ser caracterizada como

matriz identidade, entre outras características. A Tabela 7 a seguir lista esses

métodos e uma breve descrição de sua funcionalidade.


IntervalMatrix


public boolean equals(Object arg0) Retorna sinalização se uma matriz possui

elementos iguais a outra matriz de

intervalos parametrizada.

public boolean isIdentidyMatrix() Retorna sinalização se uma matriz de

intervalos possui a propriedade de

identidade.

public boolean isNullMatrix() Retorna sinalização se uma matriz de

intervalos possui a propriedade de

nulidade.

public Interval getIntervalAt(int

line, int column)

Retorna intervalo de uma matriz de

intervalos a partir da parametrização de

linha e coluna.

De maneira similar ao tipo Interval, após a definição da classe que

representa as matrizes de intervalos viu-se a necessidade de desenvolver

operações para esse novo tipo. Para manter mais uma vez a modularidade da

biblioteca foram criada novas classes para agrupar as operações sobre o tipo

IntervalMatrix. As classes foram denominadas de

IntervalMatrixElementary e IntervalMatrixSet, e são responsáveis,

respectivamente, por agrupar as operações aritméticas e lógicas para os tipos de

dados matriciais intervalares. Todas as operações destas classes foram baseadas

nas operações definidas nas classes IntervalElementary e IntervalSet

41

definidas na subseção anterior, uma vez que já tinham sido validadas e testadas

(processo detalhado na subseção 3.3.1 deste documento). A seguir, as Tabelas 8 e

9, exibem as funcionalidades implementadas referentes a matrizes de intervalo e

uma breve descrição.


IntervalMatrixElementary


public static IntervalMatrix

add(IntervalMatrix arg0, IntervalMatrix

arg1)

Retorna matriz de intervalos

com a soma de duas matrizes

parametrizadas.


sub(IntervalMatrix arg0, IntervalMatrix

arg1)


com a subtração de duas

matrizes parametrizadas.


mulInterval (IntervalMatrix arg0, Interval

arg1)


com a multiplicação de um

intervalo por uma matriz

parametrizada.


mul(IntervalMatrix arg0, IntervalMatrix

arg1)


com a multiplicação de duas



IntervalMatrixSet



interscetion(IntervalMatrix arg0,

IntervalMatrix arg1)


com a interseção de duas



union(IntervalMatrix arg0, IntervalMatrix

arg1)


com a união de duas matrizes

parametrizadas.

public static boolean

pertains(IntervalMatrix arg0,

IntervalMatrix arg1)

Retorna sinalização se a matriz

representada pelo parâmetro

arg1 está contida na matriz

representada pelo parâmetro

arg0.

42

3.1.2.4 MÓDULO TRANSCENDENTAL

Uma vez definidos os tipos básicos da biblioteca intervalar, foram criadas

operações adicionais para enriquecer a biblioteca. Entre os módulos adicionais, o

módulo transcedental inclui as funcionalidades: exponencial e logarítmica.

A implementação das funcionalidades transcendentais foi realizada da

seguinte maneira: as funções transcendentais são aplicadas aos limites inferior e

superior dos intervalos, e os resultados são submetidos a arredondamentos (caso

necessário) através da classe IntervalRounding. Então, um novo intervalo é

criado com os novos resultados obtidos. Dessa maneira foi criada a classe

IntervalExpLog para representar as funções transcendentais intervalares da

biblioteca intervalar Java. Na Tabela 10 a seguir está um resumo dos métodos

desenvolvidos:


IntervalExpLog


public static Interval exp(Interval

arg0)

Retorna intervalo na base neperiana do

intervalo parametrizado.

public static Interval log(Interval

arg0)

Retorna intervalo com operação de

logarítmico neperiano do intervalo

parametrizado.

3.1.2.5 MÓDULO TRIGONOMÉTRICO

Outro módulo incluído no projeto refere-se às funções trigonométricas para

intervalos. Embora sejam consideradas na literatura como funções transcendentais,

achou-se melhor desenvolver um módulo a parte para estas operações. Como a

43

maioria das funções trigonométricas utiliza o valor da constante

em suas

operações, foi definido na classe IntervalTrig uma constante com esse

propósito. Para manter coerência com a quantidade de casas decimais da primitiva

double Java, a constante possui o mesmo número de casas decimais, quatorze.

O artifício para desenvolvimento das funções foi aplicar a definição da função

aos limites do intervalo e gerar um novo intervalo a partir das respostas. Para isso,

foi de grande valia a utilização das funções da biblioteca padrão Java java.lang.Math

[SUN MICROSYSTEMS, 2005]. Na Tabela 11, estão disponíveis as funções

implementadas:


IntervalTrig


public static Interval sin(Interval

arg)

Retorna intervalo com operação de seno

aplicada ao intervalo parametrizado.

public static Interval cos(Interval

arg)

Retorna intervalo com operação de co-

seno aplicada ao intervalo parametrizado.

public static Interval tan(Interval

arg)


tangência aplicada ao intervalo

parametrizado.


cotan(Interval arg)


tangência aplicada ao intervalo

parametrizado.

public static Interval sec(Interval

arg)


secante aplicada ao intervalo

parametrizado.


cosec(Interval arg)


secante aplicada ao intervalo

parametrizado.

44

3.1.2.6 MÓDULO ESTATÍSTICO

Por fim, foi desenvolvido um módulo correspondente às funções ou

indicadores estatísticos. O incentivo e a idéia da criação desse módulo partiram da

necessidade de saber informações para amostras de um conjunto de intervalos.

Embora as funções estatísticas sejam complicadas em sua teoria matemática, as

operações envolvidas nos cálculos dos indicadores estatísticos são as elementares

já disponibilizadas nos outros módulos da biblioteca, tendo sido realizado então

apenas um reuso e combinação delas para gerar este novo módulo [LORETO,

2005].

Como exemplo disso, podemos citar a operação de média intervalar, onde

são adicionados os intervalos desejados, através da operação de soma disponível

no módulo intervalar. Esse valor é dividido pela quantidade de intervalos somados,

operação também disponível no módulo intervalar, para obtenção da média do

conjunto de intervalos. Assim também, foram implementadas as outras operações

estatísticas deste módulo: variância intervalar, desvio padrão intervalar e coeficiente

de variação intervalar.

Na Tabela 12 a seguir está um resumo das assinaturas das operações

definidas na classe IntervalStatistics acompanhadas de uma descrição:

45


IntervalStatistics



mediaIntervalar(Interval[] intervalos)

Retorna o valor médio para um

dado conjunto de intervalos

parametrizado.


varianciaIntervalar(Interval[] x)

Retorna a variância intervalar.


desvioPadraoIntervalar(Interval[] x)

Retorna o desvio padrão

intervalar.


coeficienteDeVariacaoIntervalar(Interval[] x)

Retorna o coeficiente de

variação intervalar.

3.1.2.7 MÓDULO UTILITÁRIO

Adicionalmente foram criadas classes para tratar possíveis exceções

ocorridas durante a manipulação dos tipos e operações definidos. Essas classes têm

como único objetivo fornecer garantia aos usuários de que não ocorram erros em

tempo de execução (Run Time Exceptions) e fornecer mensagens de erros

amigáveis e claras, quando seja executada alguma operação inválida..

Todas essas classes herdam da classe java.lang.Exception [SUN

MICROSYSTEMS, 2005], onde são incluídas mensagens de erros correspondentes

as possíveis falhas de operação da biblioteca. Segue listagem abaixo com breve

descrição das exceções tratadas na biblioteca:

InvalidOperationMatrix

Exceção levantada nos métodos das classes

IntervalMatrixElementary e IntervalMatrixSet. Esta classe de

exceção define constantes que indicam em qual operação ocorreu o

problema, conforme trecho de código abaixo:

46

public static final int OPERATION_SUM = 0;

public static final int OPERATION_SUB = 1;

public static final int OPERATION_MUL = 2;

public static final int OPERATION_DIV = 3;

public static final int OPERATION_INTERSECTION = 4;

public static final int OPERATION_UNION = 5;

IllegalPositionMatrix

Exceção levantada durante a manipulação de

intervalos numa matriz intervalar. Na classe IntervalMatrix, nos

métodos getIntervalAt() e putIntervaltAt() existe um tratamento

para evitar que posições não declaradas da matriz sejam acessadas. Caso

ocorra, a exceção é levantada informando linha e coluna de acesso indevido.

IllegalConstructorIntervalMatrix

Exceção levantada no

construtor da classe IntervalMatrix para tratar declarações de graus

negativos para a matriz intervalar.

3.1.3 TESTES E VALIDAÇÃO

Para validação dos resultados da biblioteca intervalar Java aqui proposta

foram realizados cálculos utilizando as operações definidas nas seções anteriores e

os resultados foram comparados com o software IntpakX [INTPAKX, 1999], que é

uma extensão intervalar do Maple [MAPLE, 2005]. A escolha da ferramenta Maple

foi escolhida por ser amplamente divulgada na literatura. A versão do software

Maple escolhida foi a versão 7.0. A versão Java utilizada foi a Java 2 Platform,

Standard Edition, v 1.4.2 (J2SE).

47

Para realização dos testes foram criados nas próprias classes da biblioteca

métodos estáticos (assinatura dos métodos public static void main(String

args[])) para execução das funções implementadas. Ou seja, para cada módulo

desenvolvido eram realizados testes unitários, cujos valores das operações eram

comprados com os resultados do Maple.

Para os testes em massa, os seus resultados foram salvos em arquivos para

uma posterior avaliação. De maneira similar as mesmas operações, com mesmos

valores e parâmetros, foram codificadas no Maple e seus valores também foram

arquivados para posterior comparação e validação.

A Tabela 13, a seguir, apresenta os resultados obtidos com Java-XSC e

IntpakX, e calcula as distâncias, real e intervalar, definidas, respectivamente, pelas

fórmulas abaixo:

d = |xi - xj|,

d = max{|a1 b1|, |a2 b2|}.

48

Tabela 13: Comparação entre resultados obtidos com Java-XSC e IntpakX

Java - XSC IntpakX Arredondamento para baixo de 2.0 com precisão de 10-9

1.999999999 1.999999999

d = 0

Arredondamento para baixo de 3.88888888899 com precisão de 10-9

3.888888888 3.888888888

d = 0

Arredondamento para baixo de -1.6564564876648 com precisão de 10-9

-1.656456488 -1.656456489

d = 0.00000001

Arredondamento para cima de 2.0 com precisão de 10-9

2.000000001 2.000000001

d = 0

Arredondamento para cima de 3.88888888899 com precisão de 10-9

3.888888890 3.888888890

d = 0

Arredondamento para baixo de -1.6564564876648 com precisão de 10-9

-1.656456486 -1.656456487

d = 0.00000001

Comprimento de [1.0, 2.5] 1.5 1.5

d = 0

Recíproco de [-3.0, 8.4] com precisão de 10-9

[-Infinity, Infinity] [-Infinity, Infinity]

d = 0

Recíproco de [-5.0, -2.0] com precisão de 10-9

[-0.500000001, -0.199999999] [-0.500000001, -0.199999999]

d = 0

[0.5684, 8.7584] pertence a [0.5684, 8.7584] 1] true true

Adição entre [0.5684, 8.7584] e [0.5684, 8.7584] com precisão de 10-9

[3.5688, 14.8858] [3.568799999, 14.88580001]

d = 1.000000082740371E-9

Subtração entre [0.5684, 8.7584] e [3.0004, 6.1274] com precisão de 10-9

[-5.559, 5.758] [-5.559000001, 5.758000001]

d = 1.000000082740371E-9

Multiplicação entre [0.5684, 8.7584] e [3.0004, 6.1274] com precisão de 10-9

[1.70542736, 53.66622016] [1.705427359, 53.66622017]

49

d = 1.000000082740371E-9

Divisão entre [0.5684, 8.7584] e [3.0004, 6.1274] com precisão de 10-9

[0.092763651, 2.919077457] [0.09276365171, 2.919077458]

d = 7.100000032345122E-10

Java - XSC IntpakX Interseção entre [0.5684, 8.7584] e [3.0004, 6.1274] com precisão de 10-9

[3.0004, 6.1274] [3.0004, 6.1274]

d = 0.0

União entre [0.5684, 8.7584] e [3.0004, 6.1274] com precisão de 10-9

[0.5684, 8.7584] [0.5684, 8.7584]

d = 0.0

Exponenciação de [0.5684, 8.7584] com precisão de 10-9

[1.765440086, 6363.92115398] [1.765440085, 6363.921155]

d = 9.99999860695766E-10

Exponenciação de [3.0004, 6.1274] com precisão de 10-9

[20.093572745, 458.243178212] [20.09357274, 458.2431783]

d = 5.000000413701855E-9

Raiz quadrada de [0.5684, 8.7584] com precisão de 10-9

[0.753923072, 2.959459411] [0.3230785599, 76.70957057]

d = 0.43084451209999997

Raiz quadrada de [3.0004, 6.1274] com precisão de 10-9

[1.732166273, 2.47535856] [9.002400159, 37.54503077]

d = 7.270233886000001

Seno de [0.5684, 8.7584] com precisão de 10-9

[-1.0, 1.0] [-1.0, 1.0]

d = 0.0

Seno de [3.0004, 6.1274] com precisão de 10-9

[-1.0, 0.140724] [-1.0, 0.1407240009]

d = 0.0

Coseno de [0.5684, 8.7584]] com precisão de 10-9

[-1.0, 1.0] [-1.0, 1.0]

d = 0.0

Coseno de [3.0004, 6.1274] com precisão de 10-9

[-1.0, 0.987889991] [-1.0, 0.9878899906]

d = 0.0

Tangente de [0.5684, 8.7584] com precisão de 10-9

[-1.0, 1.0] [-infinity, infinity]

Como pode-se notar os resultados foram bastantes satisfatórios, uma vez que

a distância entre os resultados do intpakX e da biblioteca JAVA-XSC tendem se sua

maioria ao valor zero.

50

Importante ressaltar que operações como raiz quadrada e divisão não

apresentaram resultados semelhantes entre o IntpakX e Java-XSC. Durante o

período de testes podemos observar que o comportamento da ferramenta IntpakX

para essas operações devolvia resultados não esperados, como por exemplo um

intervalo de intervalos como resposta.

3.2 CALCULADORA INTERVALAR

Uma vez implementada a biblioteca Java-XSC, sentiu-se a necessidade de

disponibilizar suas funcionalidades através de uma interface gráfica por meio de uma

versão desktop. Portanto, esta subseção tem o objetivo de detalhar a metodologia

utilizada para desenvolvimento desta interface.

A metodologia seguida foi a de design voltada para o usuário [NORMAN,

2004], ou seja, com sua participação durante o processo de desenvolvimento. Dessa

maneira, o processo torna-se iterativo podendo a cada nova fase ocorrerem

descobertas de novas necessidades por parte dos usuários e serem realizadas

novas adaptações na interface.

A seguir serão apresentadas as técnicas utilizadas para desenvolvimento da

interface e como elas contribuíram para conclusão da versão final da calculadora

intervalar.

3.2.1 TÉCNICA 1: ABSTRAÇÃO

A técnica da abstração objetiva encontrar generalizações, ou seja, buscar de

uma forma imparcial atividades e fluxos que podem ser executados para resolução

51

do problema em questão. O propósito é compreender e articular regras que se

aplicam ao domínio do conhecimento da aplicação e descobrir regras que possam

ser compartilhadas com outras áreas.

Está técnica, possivelmente, é a mais comum e presente na maioria dos

processos de análise e desenvolvimento de software, pois ignora detalhes

desnecessários, possibilita mesmo tratamento para entidades diferentes e simplifica

consideravelmente a análise. Geralmente é utilizada de maneira inconsciente, pois

visa apenas iniciar o processo de criação iterativa da interface homem máquina.

A técnica abstrativa não resolve os problemas que os softwares se propõem a

solucionar, mas simplifica-os e torna-se ponto de partida para buscar e aprofundar o

conhecimento das necessidades e interesses dos usuários em outras técnicas. No

caso da calculadora Intervalar em particular, a abstração está presente até no

processo de implementação do software propriamente dito, uma vez que se deve

modelar o espaço real e infinito dos números em um intervalo numérico limitado

representado por uma máquina.

3.2.2 TÉCNICA 2: BRAINSTORM

Outra técnica de desenvolvimento de interface voltada para o usuário, foi o

Brainstorm que se define como uma reunião de um grupo de pessoas de interesse

comum para sugerir diferentes idéias para resolução do problema. O foco é propor

e colher o máximo de idéias possível, sem levantar relevâncias com os valores que

as sugestões possam agregar ou não ao sistema final. Apesar de muitos pontos

citados durante o processo de discussão parecerem desprezíveis a primeira vista,

pode ser de grande valia para descobrir diversos requisitos dos usuários finais.

52

Embora muitas sugestões tenham sido levantadas, muitas foram descartadas

pelo elevado grau de complexidade que seria gasto com a interface e seria inviável

para desenvolvimento nesta fase do trabalho. Porém, outros pontos citados

ajudaram na proposta e desenvolvimento incremental da interface do software e

estão enumerados abaixo.

Interface deve apresentar: modo calculador padrão e um módulo

intervalar separadamente para manter legado de operações não

intervalares

Suporte para operações intervalares com operações aritméticas

tradicionais

Suporte para cálculos intervalares básicos, transcendentais,

estatísticos e matriciais

Criação de versão para permitir acesso as funcionalidades da

aplicação via Web

Inclusão de uma tela de ajuda (descriminado as funcionalidade da

interface)

3.2.3 TÉCNICA 3: PROTOTIPAÇÃO

No processo de desenvolvimento do design da interface da calculadora

intervalar Java utilizou-se a prototipação através de rascunhos em papel (skecths)

para apresentação aos usuários, por ser um mecanismo barato, fácil de modificar,

amigável e relativamente rápido.

53

A seguir estão algumas versões dos rascunhos em papel feitos durante o

processo e suas evoluções. As sugestões encontradas e discutidas durante as

outras técnicas serviram para avanços significativos na interface.

Figura 32: Protótipo inicial em rascunho de papel

Figura 33: Protótipo revisado em rascunho de papel

54

A partir do uso desta metodologia científica é que foi realizado o processo de

construção da interface da calculadora intervalar. Com o uso de um método

científico, a análise e o processo tomam formas organizadas e produzem resultados

mais concisos e coerentes para o conjunto da aplicação.

Para a construção deste módulo gráfico foi utilizado o plug-in da ferramenta

eclipse denominado visual editor [ECLIPSE, 2004] que facilita o desenvolvimento

gráfico uma vez que disponibiliza todos os componentes gráficos da linguagem.

Como se pode verificar através das Figuras 34, 35 e 36 a seguir, a interface

implementada é bastante simples e intuitiva para o uso das funções da biblioteca

intervalar. A interface foi dividida em abas que agrupam as funções desenvolvidas

na biblioteca de acordo com o número de operandos. Dessa maneira, a interface

ficou particionada em um módulo de operações unárias, um módulo de operações

binárias e um módulo estatístico que opera sobre um conjunto de intervalos.

A Figura 34 ilustra o módulo das operações unárias que contempla as

operações transcendentais: função logarítmica, função exponencial, função raiz

quadrada e as funções trigonométricas: seno, cosseno, tangente, cossecante,

secante e cotangente. Nesta aba é permitida a entrada dos limites inferior e superior

do intervalo, e através do combo são disponibilizadas as operações que resultam em

uma resposta intervalar exibida na tela de forma destacada e formatada de acordo

com anotação de intervalos.

55

Figura 34: Módulo de operações unárias

A Figura 35, por sua vez, exibe a aba com as operações binárias da biblioteca

intervalar que são as operações aritméticas, e as operações lógicas e de conjunto.

Nesta aba devem obrigatoriamente ser digitados dois intervalos, através de seus

limites inferior e superior. A falta de um deles acarreta a exibição de uma mensagem

da aplicação alertando a falta de parâmetros para continuidade da execução da

operação.

56

Figura 35: Módulo de operações binárias

E, finalmente, a Figura 36 detalha o módulo referente às operações

estatísticas intervalares. Como as operações estatísticas operam sobre um conjunto

de dados, a interface permite a entrada de vários intervalos através do botão incluir

disponibilizado na tela. Logicamente, os botões excluir

e limpar

apagam

determinados ou todos os intervalos inseridos, respectivamente. Após a entrada do

conjunto de intervalos basta selecionar a operação intervalar desejada e receber o

resultado conforme padronização das outras abas da interface.

57

Figura 36: Módulos de estatísticos

58

3.2.4 INSTALAÇÃO E USO DA CALCULADORA JAVA-XSC

A calculadora Java-XSC está disponível para download no endereço

http://www.cin.ufpe.br/~javaxsc/.

Estão disponibilizadas no sítio duas versões. Ambas têm como composição

um arquivo compactado com a extensão JAR, que contém todas as classes

interpretadas do projeto. A diferença é que o arquivo calculadora.jar contém além

das classes básica a parte gráfica da calculadora, funcionando assim, como uma

aplicação. Já o arquivo interval.jar destina-se aos interssados em ter a biblioteca

Java-XSC apenas como uma API de funcionalidades.

Essa estratégia foi escolhida por permitir, dessa maneira, que a biblioteca

seja incorporada a qualquer software de desenvolvimento para a linguagem Java, e

ainda, permitir sua execução direta através de linhas de comando, sendo necessário

para isso configuração de variáveis de ambiente do computador.

Após baixar os arquivos, os mesmos poderão ser colocado em qualquer

diretório do computador destino. Como configuração adicional, é necessário ajustar

a variável de ambiente do sistema operacional que determina o caminho do diretório

que contém arquivos adicionais e que devem ser reconhecidos durante execução.

Para o sistema operacional Windows, por exemplo, a variável de ambiente

configurada deve ser CLASSPATH. Abaixo está a indicação de como seria o

processo de configuração de ambiente através de uma seção DOS.

set classpath=<<diretorio_escolhido>>\interval.jar;%classpath%

set classpath=<<diretorio_escolhido>>\calculadora.jar;%classpath%

http://www.cin.ufpe.br/~javaxsc/

59

Similarmente, o processo seria o mesmo para o sistema operacional linux,

alterando apenas o nome da variável de ambiente a ser utilizada.

Após a configuração do ambiente, a biblioteca estará disponível para uso

através de ferramentas para desenvolvimento Java, ou ainda, será possível, a

utilização da calculadora através da seguinte linha de comando:

java javaxsc.intervals.gui.CalculadoraIntervalar

Importante ressaltar que é necessário ter instalado no computador uma

versão da máquina virtual Java, disponível na web [SUN MICROSYSTEMS, 2005],

da versão 1.4 ou superior.

Após instalação, a biblioteca está disponível para uso, seja conforme uma API

para o desenvolvimento de aplicações que necessitem de seus benefícios, ou

através da interface da calculadora, onde será exibida uma aplicação conforme as

Figura 34, 35 e 36 da seção anterior.

Na parte superior da calculadora são disponibilizadas abas que agrupam as

funções de acordo com o número de operandos, Figura 37. O fato de utilizarmos

esse critério para agrupamento foi entender que a interface tornar-se-ia menos

confusa e visualmente poluída, não sendo necessária a criação de várias abas para

agrupar as funcionalidades por característica de operação.

60

Figura 37: Interface da Calculadora Intervalar I

O usuário pode navegar nessas abas livremente, e inserir os limites inferior e

superior dos intervalos desejados nos espaços que contém a descrição Insira

Intervalos conforme Figura 37.

A figura acima utiliza a aba referente ao módulo estatístico da biblioteca, mas

as explicações referentes as abas, bem como os elementos de entrada dos

intervalos são similares para as operações unárias e binárias.

Conforme Figura 38 abaixo, na parte inferior da tela, as operações são

disponibilizadas através do componente combo box. Quando uma das operações é

selecionada, automaticamente os valores dos intervalos utilizados como parâmetros

são calculados de acordo com a operação definida e o resultado é disponibilizado no

campo Resultado .

Abas para navegação Entrada de Intervalos

61

Figura 38: Interface da Calculadora Intervalar II

Caso uma nova operação seja selecionada, automaticamente o resultado

também é atualizado na tela. Diferentemente, caso o usuário altere os parâmetros é

necessário selecionar a mesma ou outra operação para obter o resultado.

Particularmente, a aba Estatísticos possui botões adicionais que incluem,

excluem ou limpam os intervalos parametrizados para as operações. Isto foi

necessário porque essas operações manipulam um conjunto de intervalos, ao

contrário das outras que possuem no máximo dois intervalos como parâmetros.

Através dos botões, os intervalos digitados são incluídos ou excluídos da área

disponibilizada para sua visualização conforme Figura 39 abaixo.

Resultado das operações Operações disponíveis

62

Figura 39: Interface da Calculadora Intervalar III

Dessa maneira, a calculadora permite n intervalos como parâmetros para as

operações estatísticas. Para obter o resultado da operação é necessário conforme

orientação anterior selecionar a operação desejada no combo de operações

disponíveis.

Intevalos parametrizados Botões de ação

63

4. ESTUDO DE CASO

A aplicação da calculadora intervalar em Java, aqui proposta, consistiu em, a

partir de um conjunto de dados, usar a calculadora para computar os estatísticos

usuais. Os dados consistiram de 24 observações sobre consumo de energia elétrica

de uma dada residência. Estes valores encontram-se na Tabela 14 a seguir.

Tabela 14: Valores do consumo de energia elétrica em números reais

Mês/Ano Consumo

(Kwh)

Mês/Ano Consumo

(Kwh)

jun / 2004 120 jun / 2005 116

jul / 2004 125 jul / 2005 126

ago / 2004 111 ago / 2005 139

set / 2004 140 set / 2005 126

out / 2004 121 out / 2005 133

nov / 2004 123 nov / 2005 116

dez / 2004 138 dez / 2005 129

jan / 2005 123 jan / 2006 133

fev / 2005 138 fev / 2006 140

mar / 2005 102 mar / 2006 131

abr / 2005 114 abr / 2006 140

mai / 2005 161 mai / 2006 164

Para calcular os indicadores estatísticos (reais ) foi utilizada a ferramenta

NetBook [NETBOOK, 2004]. A Tabela 15 exibe os resultados encontrados.

Tabela 15: Indicadores estatísticos reais (resultados são números reais)

Estatístico Valor

Média 129.54166666666666

Variância 207.38949275362322

Desvio Padrão 14.401024017535114

Coeficiente de variação 0.11116904999062167

64

A seguir, os dados reais foram transformados em intervalos, com precisão de

4 casas decimais com um erro de 0,05 e os indicadores estatísticos intervalares

foram computados através da calculadora intervalar proposta neste trabalho. Estes

valores estão na Tabela 16 e 17.

Tabela 16: Valores do consumo de energia elétrica em intervalos

Mês/Ano Consumo (Kwh)

Mês/Ano Consumo (Kwh)

jun / 2004 [119.95, 120.05] jun / 2005 [115.95, 116.05]

jul / 2004 [124.95, 125.05] jul / 2005 [125.95, 126.05]

ago / 2004 [110.95, 111.05] ago / 2005 [138.95, 139.05]

set / 2004 [139.95, 140.05] set / 2005 [125.95, 126.05]

out / 2004 [120.95, 121.05] out / 2005 [132.95, 133.05]

nov / 2004 [122.95, 123.05] nov / 2005 [115.95, 116.05]

dez / 2004 [137.95, 138.05] dez / 2005 [128.95, 129.05]

jan / 2005 [122.95, 123.05] jan / 2006 [132.95, 133.05]

fev / 2005 [137.95, 138.05] fev / 2006 [139.95, 140.05]

mar / 2005 [101.95, 102.05] mar / 2006 [130.95, 131.05]

abr / 2005 [113.95, 114.05] abr / 2006 [139.95, 140.05]

mai / 2005 [160.95, 161.05] mai / 2006 [163.95, 164.05]

Tabela 17: Indicadores estatísticos intervalares

Estatístico Valor (intervalar)

Média [129.4916,129.5917]

Variância [205.1023,209.6976]

Desvio Padrão [14.3214, 14.4809]

Coeficiente de variação

[0.1105, 0.1119]

Considerando que as 24 observações sobre o consumo de energia elétrica na

específica residência são amostras aleatórias desta variável, calculou-se um

intervalo de confiança, que chamaremos a partir deste ponto de IC, para o consumo

médio considerando a variância desconhecida.

65

Com um nível de confiança de 95% o intervalo de confiança encontrado foi

IC = [125,3602 , 133,7232].

O consumo médio intervalar, conforme Tabela 17, foi,

[129.4916, 129.5917].

Portanto,

[129.4916, 129.5917] [125,3602 , 133,7232].

Como pode-se observar, o consumo médio intervalar está contido no intervalo

de confiança calculado a partir das medidas em números reais. Da mesma maneira

os indicadores estatísticos reais, também estão contidos nos respectivos estatísticos

intervalares, como mostra a tabela abaixo. Os valores em reais estão com uma

precisão de 4 dígitos após o ponto decimal.

Tabela 18: Valores reais x Valores intervalares

Estatístico Valores reais X Valor intervalares

Média 129.5417 [129.4916,129.5917]

Variância 207.3895 [205.1023,209.6976]

Desvio Padrão 14.40105 [14.3214, 14.4809]

Coeficiente de variação

0.1112

[0.1105, 0.1119]

66

5. CONCLUSÔES E TRABALHOS FUTUROS

Sistemas computacionais são incapazes de representar todos os números

reais devido a sua densidade. A representação digital é discreta e atinge uma

limitada faixa de valores. Java, como as outras linguagens de programação, possui

esta limitação, realçada ainda mais com a não implementação de importantes

aspectos padronizados pelo IEEE para a aritmética de máquina. Por isso, Java

apresenta erros quando realiza operações de ponto flutuante.

Neste trabalho foi desenvolvida uma biblioteca intervalar, Java-XSC, para

solucionar este problema. Além disso, foi construída uma calculadora intervalar que

apresenta as funcionalidades intervalares de uma maneira didática e de fácil

utilização para profissionais da área de computação científica ou de interesse

comum.

As facilidades da linguagem Java, entre elas reuso e aspectos de herança,

permitiram o desenvolvimento modular e robusto da biblioteca intervalar. Pode-se

considerar a classe Interval, que representa o tipo intervalo, como sendo a raiz

do processo de desenvolvimento. Portanto, todos os módulos seguintes do sistema

a utilizam como axioma para suas funcionalidades.

A biblioteca Java-XSC contempla os módulos abaixo:

Arredondamento direcionado

Tipo Intervalo.

Tipo Matriz de Intervalos.

Operações elementares matriciais.

o Soma, subtração, multiplicação, divisão, raiz quadrada.

67

Operações entre conjunto.

o União, interseção, união complementar.

Operações transcendentais.

o Exponenciação e Logarítmica.

Operações trigonométricas.

o Seno, cosseno, tangente, secante, cossecante e cotangente.

Cálculo de estatísticos.

o Média, variância, desvio padrão e coeficiente de variação.

Quando comparada como o software matemático IntpakX, os resultados

obtidos com a calculadora Java-XSC foram satisfatórios conforme mostrou a

distância calculada entre eles (Tabela 13).

Como trabalhos futuros citamos:

Complementar a biblioteca Java-XSC como módulos que forneçam

suporte a aritmética intervalar complexa, ou seja, definição deste novo

tipo e de suas operações.

Incrementar a calculadora intervalar disponibilizando versões para sua

utilização diretamente na web.

Adicionar operações de matrizes intervalares através da interface.

Incrementar avanços na interface como geração de gráficos das

funções calculadas.

Comparar resultados obtidos entre a biblioteca Java-XSC e outras

bibliotecas intervalares.

68

Comparar os resultados entre a biblioteca desenvolvida e a linguagem

Java padrão para avaliar a contribuição do módulo intervalar na

linguagem.

69

REFERÊNCIAS

BEZERRA, E. S. R., LOUREIRO, J. A., ZARZAR, G. C. B., CAMPOS, M. A. Análise

Estatística do Serviço de Eventos do OpenORB. In: Encontro Norte Nordeste de

Matemática Aplicada e Computacional, Recife, 2004.

BEZERRA, E. S. R., FERNANDES, B., CAMPOS, M. A.; T; FERREIRA, R.. V. Java-

XSC - Uma biblioteca Intervalar para Java. In: Encontro Regional de Matemática

Aplicada e Computacional, Natal, 2005.

CAMPOS, M.A., FERNANDES, B., CAMPOS, M. A.; T; FERREIRA, R. V. NetBook:

Uma ferramenta para avaliação de desempenho de sistemas de comunicação.

In: Salão de Ferramentas, 2004, Gramado, RS. Simpósio Brasileiro de Redes de

Computadores, 2004.

CAMPOS, M. A; FIGUEIREDO, P. L., Introdução ao Tratamento da Informação

nos Ensinos Fundamental e Médio, 2005.

CHOUDHARI, P., Java Advantages & Disadvantages, 2001. Disponível em:

http://arizonacommunity.com/articles/java_32001.shtml Acesso em: 12/06/2005.

DEITEL, H. M.; DEITEL, P. J. Java como programar. 3. Ed. Porto Alegre:

Bookman, 2001. ISBN: 85-7307-727-1.

DIVÉRIO, T. A.; OLIVEIRA, P. W; CLAUDIO, D. M. Fundamentos da Matemática

Intervalar. Porto Alegre: Sagra-Luzzatto, 1997. 93p. (Série Matemática da

Computação e Processamento Paralelo, v.1, Instituto de Informática da UFRGS,

Projeto ArInPar-ProTeM-CNPq) ISBN 85-241-0515-1

DUTRA, Enéas Montenegro Dutra. Java XSC: Uma Biblioteca Java para

Computações Intevalares. Dissertação de Mestrado em Ciências da Computação,

Departamento de Informática e Matemática Aplicada, Universidade Federal do Rio

Grande do Norte, Natal, 2000.

http://arizonacommunity.com/articles/java_32001.shtml

70

ECLIPSE, Eclipse.org. Disponível na internet em: http://www.eclipse.org/. Acesso em

30/07/2005.

FERNANDES, B., CAMPOS, M. A.; T; FERREIRA, R.. V. Evaluating the floating-

point in Java Virtual Machine, Proceedings ENNEMAC, Natal, 2004.

GOSLING, J.; JOY, B., STEELE G., (1996), The Java Language Specification,

Disponível em: http://java.sun.com/docs/books/jls/second_edition/html/j.title.doc.html.

Acesso em 01/05/2006.

GREEN, R. Java Glossary: Floating Point. Disponível em:

http://mindprod.com/jgloss/floatingpoint.html. Acesso em 12/06/2005.

INTPAKX. Disponível em http://www.math.uni-wuppertal.de/~xsc/software/intpakX/.

Acesso em: 11/06/2006.

JUDE, Jude Comunity.. Jude UML Modeling Tool. Disponível em: http://jude.change-

vision.com. Acesso em: 12/02/2006.

KNUTH, Donald E.;. The Art of Computer Programming. Volume 2. ed. Adisson

Wesley, 1997. ISBN: 0201485419.

KRAMER, W; GEULIG, I; Interval Calculus in Maple: The Extension intpakX to

the Package intpak of the Share-Library. Disponível em: http://www.math.uni-

wuppertal.de/wrswt/literatur.html. Acesso 11/06/2006.

KULISCH, U. W; A new aritmetic for Scientific Computation. Em U. W Kulisch

abd W.L. Miranker, editors. A new Approach to Scientific Computation, pages 1 26.

Proceeding of Symposium held at IBM Researche Center, Torktown Heights, N. Y,

Academic Press, 1983.

LORETO, B. A., NEVES, L. M., ALMEIDA, E.W.M., SANTOS, D.P., NASCIMENTO,

T.A.S, MARTINS, J.G.Q.L., CAMPOS, M.A. Computação das medidas de

Tendência Central e Dispersão Intervalares em Java. In: Encontro Regional de

Matemática Aplicada e Computacional, Natal, 2005.

http://www.eclipse.org/

http://java.sun.com/docs/books/jls/second_edition/html/j.title.doc.html

http://mindprod.com/jgloss/floatingpoint.html

http://www.math.uni-wuppertal.de/~xsc/software/intpakX/

http://jude.change-

http://www.math.uni-

http://wuppertal.de/wrswt/literatur.html

71

MAPLE, MapleSoft.com. Disponível em: http://www.maplesoft.com/. Acesso em

22/10/2005.

MICROSOFT Corporation, Tutorial to Understand IEEE Floating-Point Errors.

Disponível em http://support.microsoft.com/kb/q42980/. Acesso em 12/01/2005.

MOORE, R. E. Methods and Aplications of Intervals Analysis. Society for

Industrial and Applied Mathematics, Philadhelpia, PA, USA, 1979.

NORMAN, Denzin K., LINCON, Yvonna S. Strategies of Quality Inquiry. Sage

Publications International Educational and Professional Publisher, USA 2004.

SUN MICROSYSTEMS, Java Language Overview, Java 2 Platform, Standard

Edition, White Papers. Disponível em: http://java.sun.com/docs/overviews/java/java-

overview-1.html. Acesso em: 13/01/2005.

http://www.maplesoft.com/

http://java.sun.com/docs/overviews/java/java-

overview-1.html

This document was created with Win2PDF available at http://www.daneprairie.com.The unregistered version of Win2PDF is for evaluation or non-commercial use only.

http://www.daneprairie.com

Edmo Sérgio Ribeiro Bezerra€¦ · ii Bezerra,Edmo Sérgio Ribeiro Uma calculadora intervalar em...

Documents

Transcript of Edmo Sérgio Ribeiro Bezerra€¦ · ii Bezerra,Edmo Sérgio Ribeiro Uma calculadora intervalar em...