From 214c84417dab0d3e45257669d79127688f1c15c4 Mon Sep 17 00:00:00 2001
From: Balhau <balhau@balhau.net>
Date: Wed, 12 Feb 2014 00:07:27 +0000
Subject: [PATCH] Sudoku initial commit

---
 corelib.js | 2379 +++++++++++++++++++++++++++++++++++++++++++++
 css.css    |   57 ++
 index.html |   62 ++
 js.js      | 2702 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 sudoku.js  |  258 +++++
 test.html  |   12 +
 6 files changed, 5470 insertions(+)
 create mode 100644 corelib.js
 create mode 100644 css.css
 create mode 100644 index.html
 create mode 100644 js.js
 create mode 100644 sudoku.js
 create mode 100644 test.html

diff --git a/corelib.js b/corelib.js
new file mode 100644
index 0000000..dcce2c1
--- /dev/null
+++ b/corelib.js
@@ -0,0 +1,2379 @@
+/**
+ * Extensões a objectos de javascript
+ * Rotinas de encriptação
+ * Funções matemáticas
+ * @author Vítor Hugo Fernandes (a.k.a Balhau)
+ * @copyright Este documento está licenciado sob os direitos do MIT license
+ */
+
+/**
+ * Objecto que representa propriedades comuns aos algoritmos
+ */
+var ALG={};
+/**
+ * Número de iteracções feitas pelo algoritmo
+ */
+ALG.ITER=0;
+/**
+ * Variável que representa a chave secreta gerada pelo algoritmo de Vigénere. Isto ocorre sempre
+ * que a chave não é especificada à entrada da função
+ */
+ALG.VIGSECRETKEY="";
+
+/**
+ * Método que troca dois elementos num array
+ * @param {int} i Indice da posicao
+ * @param {int} j Indice da posicao
+ */
+Array.prototype.troca=function(i,j){
+	if((i<this.length && i>=0) && (j<this.length && j>=0)){
+		var aux=this[i];
+		this[i]=this[j];
+		this[j]=aux;	
+	}
+};
+
+Array.prototype.classpos=function(el){
+	var p;
+	for(var i=0;i<this.length;i++){
+		p=this[i].pos(el);
+		if(p!=-1)
+			return i;
+	}
+	return -1;
+}
+/**
+ * Método que agrupa um array de elementos bidimensionais em classes
+ * @return {Array} Array de classes
+ */
+Array.prototype.groupclasses=function(){
+	var grupos=[];
+	var volta;
+	var exist;
+	var dif;
+	var par;
+	var xu=this.clona();
+	while (xu.length > 0) {
+		par = xu[0];
+		if (par[0] != par[1]) 
+			grupos[grupos.length] = par;
+		else 
+			grupos[grupos.length] = [par[0]];
+		xu.remove(0);
+		volta=true;
+		while (volta) {
+			volta=false;
+			for (var i = 0; i < xu.length; i++) {
+				dif = xu[i].less(grupos[grupos.length - 1]);
+				if (dif.length == 1) {
+					grupos[grupos.length-1]=grupos[grupos.length - 1].concat(dif);
+					xu.remove(i);
+					i--;
+					volta=true;
+				}else if(dif.length==0){
+					xu.remove(i);
+					i--;
+				}
+			}
+		}
+	}
+	return grupos;
+};
+
+/**
+ * Método que devolve um array com os elementos de arrA x arrB (produto de conjuntos)
+ * @param {Array} arrA Array de elementos 
+ * @param {Array} arrB Array de elementos
+ * @return {Array} Array de elementos (a,b) onde a em arrA e b em arrB 
+ */
+Array.produto=function(arrA,arrB){
+	var out=[];
+	for(var i=0;i<arrA.length;i++){
+		for(var j=0;j<arrB.length;j++){
+			out[out.length]=[arrA[i],arrB[j]];
+		}
+	}
+	return out;
+}
+/**
+ * Método que verifica se o array parâmetro é igual ao objecto considerado
+ * @param {Array} arrX Array para o qual se pretende testar a igualdade 
+ * @return {Boolean} true se arrX é igual ao objecto que invoca o método, false cc
+ */
+Array.prototype.equal=function(arrX){
+	if(this.length!=arrX.length)
+		return false;
+	for(var i=0;i<this.length;i++){
+		if(this[i]!==arrX[i])
+			return false;
+	}
+	return true;
+}
+/**
+ * Verifica se o array fornecido como parâmetro é igual ao objecto que invoca o método
+ * independentemente da ordem pela qual aparecem os elementos
+ * @param {Array} arrX Array de comparação
+ * @return {Boolean} true se arrX tem os mesmos elementos que o objecto que invoca o método,
+ * false cc
+ */
+Array.prototype.nordequal=function(arrX){
+	var arx=[];
+	var arx=arrX.clona();
+	if(this.length!=arrX.length)
+		return false;
+	for(var i=0;i<this.length;i++){
+		if(!arx.has(this[i]))
+			return false;
+		arx.remove(arx.pos(this[i]));
+	}
+	return true;
+}
+/**
+ * Devolve uma string com a descrição do conteudo no array
+ * @return {String} conteúdo do array
+ */
+Array.prototype.toString=function(){
+	var out="[";
+	for(var i=0;i<this.length;i++){
+		if(i!=0)
+			out+=",";
+		out+=this[i].toString();
+	}
+	out+="]";
+	return out; 
+};
+
+/**
+ * Devolve a diferença de elementos (diferença operação de conjuntos)
+ *  entre o array considerado e o que é fornecido.
+ * @param {Array} arr Array a subtrair.
+ * @return {Array} Array diferença
+ */
+Array.prototype.less=function(arr){
+	var out=[];
+	var add;
+	for(var i=0;i<this.length;i++){
+		add=true;
+		for(var j=0;j<arr.length;j++){
+			if(this[i]===arr[j])
+				add=false;
+		}
+		if(add)
+			out[out.length]=this[i];
+	}
+	return out;
+}
+
+Array.prototype.SelectionSort=function(){
+	var maximo;
+	for(var i=this.length-1;i>=0;i--){
+		maximo=i;
+		for(var j=0;j<i;j++){
+			if(this[j]>this[maximo])
+				maximo=j;
+		}
+		this.troca(i, maximo);
+	}
+}
+
+Array.prototype.ShellSort=function(){
+	var n=this.length;
+	var passo=Math.round(n/2);
+	var j=null;
+	var val=null;
+	while(passo>0){
+		for(var i=passo;i<n;i++){
+			j=i;
+			val=this[i];
+			while(j>=passo && this[j-passo]>val){
+				this[j]=this[j-passo];
+				j-=passo;
+			}
+			this[j]=val;
+		}
+		passo=Math.round(passo/2.1);
+	}
+}
+
+/**
+ * Método que efectua a operação and sobre dois arrays. Devolve um array com os elementos
+ * que coincidentes para cada posição
+ * @param {Array} arrA Array
+ * @param {Array} arrB Array
+ * @return {Array} Array com os elementos que coincidem
+ */
+Array.and=function(arrA,arrB){
+	var min=Object.min(arrA,arrB);
+	var max=Object.max(arrA,arrB);
+	var out=[];
+	for(var i=0;i<min.length;i++){
+		if(min[i]===max[i])
+			out[out.length]=min[i];
+	}
+	return out;
+};
+
+/**
+ * Verifica se um dado elemento pertence ao array
+ * @param {Object} val Elemento que se pretende verificar se pertence ao array
+ * @return{Boolean} bol Devolve verdadeiro caso o valor esteja no array, falso caso
+ * contrário. 
+ */
+Array.prototype.has = function(val){
+	for (var i = 0; i < this.length; i++) {
+		if (this[i] == val) 
+			return true;
+	}
+	return false;
+};
+
+/**
+ * Função que devolve a intersecção entre dois arrays sem levar em conta a posição 
+ * dos elementos
+ * @param {Array} arrA Array A
+ * @param {Array} arrB Array B
+ * @return {Array} arrC Array que representa a intersecção de A com B
+ */
+Array.sAnd=function(arrA,arrB){
+	var max=Object.max(arrA,arrB);
+	var min=Object.min(arrA,arrB);
+	var out=[];
+	for(var i=0;i<max.length;i++){
+		if( i<min.length){
+			if(min.has(max[i]) && !out.has(max[i]))
+				out[out.length]=max[i];
+			if(max.has(min[i]) && !out.has(min[i]))
+				out[out.length]=min[i];
+		}
+		else{
+			if(min.has(max[i]) && !out.has(max[i]))
+				out[out.length]=max[i];
+		}
+	}
+	return out;
+};
+
+
+
+/**
+ * Método que remove um elemento do array redimensionando-o
+ * @param {int} i Indice do array que pretendemos eliminar
+ * @return {Array} arr Devolve o array para efeitos de chaining
+ */
+Array.prototype.remove=function(i){
+	if (i < 0 || i >= this.length) {
+		return this;
+	}
+    this[i]=undefined;
+    for(var j=i;j<this.length-1;j++){
+    	this[j]=this[j+1];
+    }
+    this.length=this.length-1;
+    return this;
+}
+
+Array.prototype.pos=function(el){
+	var ip;
+	for(var i=0;i<this.length;i++){
+		if(this[i]===el)
+			return i;
+	}
+	return -1;
+}
+
+/**
+ * Extrai um subarray do array cujos valores se compreendem entre os índices indI e indF
+ * @param {int} indI Indice inicial
+ * @param {int} indF Indice final
+ */
+Array.prototype.subArray=function(indI,indF){
+	var out=[];
+	for(var i=indI;i<indF;i++)
+		out[i]=this[i];
+	return out;
+};
+
+/**
+ * Método que parte o array em vários sub arrays tendo como base o valor dado
+ * como entrada na função
+ * @param {Object} val Valor de separação
+ * @return {Array} Um array que contém os sub arrays do array original após
+ * a divisão pelo elemento fornecido como parâmetro de entrada
+ */
+Array.prototype.divideBy=function(valor){
+	var arrA=[];
+	var k=0;
+	var j=0;
+	var arrAx=[];
+	for(var i=0;i<this.length;i++){
+		if (this[i] === valor) {
+			arrA[k] = arrAx;
+			arrAx = [];
+			j = 0;
+			k++;
+		}
+		else {
+			arrAx[j] = this[i];
+			j++;
+		}
+	}
+	return arrA;
+};
+
+/**
+ * Método para concatenação de arrays
+ * @param {Array} arr Array que se pretende concatenar
+ * @param {Int} indini indice inicial
+ * @param {Int} indfin indice final
+ * @return {Array} A concatenação entre os dois arrays
+ */
+Array.prototype.junta=function(arr,indini,indfin){
+	if(typeof(indini)=='undefined')
+		indini=0;
+	if(typeof(indfin)=='undefined')
+		indfin=arr.length;
+	var comp=this.length;
+	for(var i=comp;i<comp+(indfin-indini);i++)
+		this[i]=arr[indini+i-comp];
+	return this;
+};
+
+var maxit=20;
+
+/**
+ * Método estático para implementação do algoritmo de quicksort
+ * @param {Array} arr Array que se pretende ordenar
+ * @return {Array} arrOrd Array ordenado
+ */
+Array.qsort = function(arr){
+	if(arr.length<=1)
+		return arr;
+	var part = Math.floor((Math.random()*arr.length));
+	var esq=[];
+	var dir=[];
+	ALG.ITER=0;
+	for(var i=0;i<arr.length;i++){
+		if(i!=part)
+		{
+			if(arr[i]<=arr[part])
+				esq[esq.length]=arr[i];
+			else
+				dir[dir.length]=arr[i];
+		}
+		ALG.ITER++;
+	}
+	return Array.qsort(esq).junta([arr[part]]).junta(Array.qsort(dir));
+};
+
+/**
+ * Algoritmo radix sort
+ * @param {Array} arr Array para ordenação
+ * @return {Object} Array ordenado a partir do algoritmo de radix sort
+ */
+Array.rsort=function(arr){
+	
+};
+
+
+/**
+ * Método de ordenação pelo algoritmo de quicksort wrapper do Método estático
+ * @return{array} Devolve o array ordenado a partir do algoritmo de quicksort
+ */
+Array.prototype.qsort=function(){
+	ALG.ITER=0;
+	return Array.qsort(this);
+};
+
+/**
+ * Método de ordenação a partir do algoritmo de bublesort
+ * @return{Array} Devolve o array ordenado a partir do algoritmo de bublesort
+ */
+Array.prototype.bsort=function(){
+	ALG.ITER=0;
+	for(var i=0;i<this.length-1;i++){
+		for(var j=0;j<this.length-1-i;j++){
+			if(this[j]>this[j+1])
+				this.troca(j,j+1);
+			ALG.ITER++;
+		}
+	}
+	return this;
+};
+/**
+ * Método que cria um array com valores aleatórios
+ * @param {int} dim Dimensão do array
+ * @param {int} low Valor minimo
+ * @param {int} sup Valor máximo
+ * @param {bool} intarray Valor booleano indicando se o array é composto por valores inteiros ou valores decimais
+ * @return {int} Array aleatório com dim elementos compreendidos entre low e sup
+ */
+Array.random=function(dim,low,sup,intarray){
+	var arr=[];
+	if(typeof(low)=='undefined')
+		low=0;
+	if(typeof(sup)=='undefined')
+		sup=100;
+	if(typeof(intarray)=='undefined')
+		intarray=true;
+	for(var i=0;i<dim;i++){
+		if(intarray)
+			arr[i]=Math.floor(Math.random()*(sup-low+1)+low);
+		else
+			arr[i]=Math.random()*(sup-low)+low;
+	}
+	return arr;
+};
+
+/**
+ * Método que mistura os elementos de um array
+ * @return {Array} arrayRand Devolve o array baralhado
+ */
+Array.prototype.randomize=function(){
+	var fin=0;
+	var comp=this.length;
+	for(var i=0;i<comp;i++){
+		fin=Math.floor(Math.random()*comp);
+		this.troca(i,fin);
+	}
+	return this;
+};
+
+/**
+ * Método que devolve um array contendo todos os codigos dos caracteres presentes na string
+ * @return {Array} arr Array com os codigos dos caracteres
+ */
+String.prototype.toCodArray=function(){
+	var arrC=[];
+	for(var i=0;i<this.length;i++){
+		arrC[i]=this.charCodeAt(i);
+	}
+	return arrC;
+}
+
+/**
+ * Método que substitui um caracter numa string
+ * @param {Number} index Posição do caracter
+ * @param {String} chr Caracter de substituição
+ */
+String.prototype.setCharAt=function(index,chr) {
+	if(index > this.length-1) return this;
+	return this.substr(0,index) + chr + this.substr(index+1);
+}
+/**
+ * Método que baralha a string de modo a que esta continue legível para o ser humano
+ * @param {String} String para conversão 
+ */
+String.shuffleText=function(str){
+	var arr=str.split(" ");
+	var tmp="";
+	var posA=0;
+	var posB=0;
+	for(var i=0;i<arr.length;i++){
+		for(var j=0;j<arr[i].length;j++){
+			if(j==0||j==arr[i].length-1)
+				;
+			else{
+				posA=1+Math.floor(Math.random()*(arr[i].length-2));
+				posB=1+Math.floor(Math.random()*(arr[i].length-2));
+				tmpChar=arr[i][posA];
+				arr[i]=arr[i].setCharAt(posA,arr[i][posB]);
+				arr[i]=arr[i].setCharAt(posB,tmpChar);
+			}
+				
+		}
+	}
+	return arr.join(" ");
+}
+
+
+/**
+ * Método que cria uma string aleatória com caracteres alfabéticos
+ * @param {Int} num Número de caracteres da string
+ * @return {String} str String formada por caracteres alfabéticos aleatória
+ */
+String.prototype.getAlphaRandom=function(num){
+	var shift=0;
+	var strOut="";
+	for(var i=0;i<num;i++){
+		shift=Math.floor(Math.random()*26);
+		strOut+=String.fromCharCode(65+shift);
+	}
+	return strOut;
+}
+
+/**
+ * Método que devolve uma string representando o valor binário do número
+ * @return {String} str String representando o número sob a numeração binária
+ */
+Number.prototype.toByteString=function(){
+    if(parseInt(this)==0)
+        return "0";
+    var aux=parseInt(this);
+    var strout="";
+    var expaux;
+    var getexp=function(val){
+        var ii=0;
+        while(Math.pow(2,ii)<=val){ii++;}
+        if(--ii < 0)
+            return 0;
+        return ii;
+    }
+    var expmax=getexp(this);
+    var expaux=expmax;
+    while(aux>0)
+    {
+        expmax=getexp(aux);
+        aux-=Math.pow(2,expmax);
+        expaux=getexp(aux);
+        strout+="1";
+        if(aux==0 && expmax>=1){
+            expmax++;    
+        }
+        while(--expmax>expaux){
+            strout+="0";
+        }
+    }
+return strout;
+}
+
+/**
+ * Método que devolve um array contendo o código binário da string
+ * @return {Array} arr Array contendo strings com a representação binária de cada um dos caractéres da string
+ */
+String.prototype.toByteArray=function(){
+	var arr=[];
+	for(var i=0;i<this.length;i++){
+		arr[i]=this.charCodeAt(i).toByteString();
+	}
+	return arr;
+}
+
+/**
+ * Método que converte uma string para uma outra string que consiste na sequência binária dos caracteres
+ * @return {String} str String que contem os caracteres representados em binário concatenados.
+ */
+String.prototype.toByteString=function(){
+	var strout="";
+	for(var i=0;i<this.length;i++){
+		strout+=this.charCodeAt(i).toByteString();
+	}
+	return strout;
+}
+
+/**
+ * Método que verifica se um determinado caracter pertence ao alfabeto
+ * @param {String} str String de comprimento 1 representando um caracter
+ * @return {Boolean} bol Verdadeiro caso o caracter pertença ao alfabeto
+ */
+String.isAlphaChar=function(str){
+	var m=str.toMaiuscula();
+	if(m.length==str.length)
+		return true;
+	return false;
+}
+
+/**
+ * Método que passa todas as minusculas a maiusculas
+ * @return {String} O método devolve o próprio objecto
+ */
+String.prototype.toMaiuscula=function(){
+	var pos=0;
+	var posA=0;
+	var str="";
+	for(var i=0;i<this.length;i++){
+		pos=this.charCodeAt(i);
+		if(pos>=97 && pos<=122){
+			posA=this.charCodeAt(i)-97;
+			str+=String.fromCharCode(65+posA);
+		}
+		else if(pos>=65 && pos<=122){
+			str+=this[i];
+		}
+		//se for o espaço
+		else if(pos==32){
+			str+=" ";
+		}
+	}
+	return str;
+}
+
+/**
+ * Método que verifica se o caracter com determinada posição na string é uma letra maiuscula
+ * do alfabeto
+ * @param {Int} ind Posição na string
+ * @return {Bool} val Verdadeiro se o caracter for uma letra maiuscula, falso caso contrário
+ */
+String.prototype.maiuscula=function(ind){
+	if(this.charCodeAt(ind)>=65 && this.charCodeAt(ind)<=90)
+		return true;
+	return false;
+}
+
+/**
+ * Método que verifica se o caracter com determinada posição na string é uma letra minuscula
+ * do alfabeto
+ * @param {Int} ind Posição na string
+ * @return {Bool} val Verdadeiro se o caracter for uma letra minuscula, falso caso contrário
+ */
+String.prototype.minuscula=function(ind){
+	if(this.charCodeAt(ind)>=65 && this.charCodeAt(ind)<=90)
+		return true;
+	return false;
+};
+
+/**
+ * @constructor Construtor da class
+ */
+var MathL=function(){};
+
+/**
+ * Expansão do número segundo o problema de Collatz Syracuse Ulam (CSU)
+ * @param Numero inteiro
+ * @return Array Sequência de inteiros até encontrar o valor 1
+ */
+MathL.CSUExpansion=function(n){
+	var a=n;
+	var out=[a];
+	while(a!=1){
+		a=(a%2==0)?a/2:a*3+1;
+		out[out.length]=a;
+	}
+	return out;
+};
+
+/**
+ * @constructor Construtor do objecto CMarkov que representa uma cadeia de Markov
+ * @param {Array} lstats Lista com os labels dos estados associados à cadeia de markov
+ * @param {Array} pobj Representa a matriz de probabilidades da cadeia de markov
+ * @param {Array} inip Representa o vector de probabilidades inicial para a cadeia de markov
+ */
+MathL.CMarkov=function(lstats,pobj,inip){
+	if(lstats.length*lstats.length!=pobj.length || lstats.length!=inip.length){
+		throw "As dimensões do número de estados não corresponde à dimensão da matriz de probabilidades ou à dimensão do vector de probabilidades iniciais";
+	}
+	this.lbels=lstats;
+	this.mp=MathL.Matriz.ArrayToMatriz(lstats.length,lstats.length,pobj);
+	this.auxmit=MathL.Matriz.ArrayToMatriz(1,lstats.length,inip);
+	this.initm=MathL.Matriz.ArrayToMatriz(1,lstats.length,inip);
+};
+
+MathL.CMarkov.prototype.iterate=function(){
+	this.auxmit=MathL.Matriz.multMatriz(this.auxmit,this.mp);
+};
+
+MathL.CMarkov.prototype.restart=function(){
+	this.auxmit=this.initm;
+};
+
+MathL.CMarkov.prototype.printIteration=function(){
+	var std="[";
+	for(var i=0;i<this.lbels.length;i++){
+		if(i!=0)
+			std+=",";
+		std+=this.lbels[i]+":"+this.auxmit.getValor(0,i);
+	}
+	std+="]";
+	return std;
+};
+/**
+ * Devolve uma string com o valor de n iteracções da cadeia de markov
+ * @param {Number} n Número de iteracções a efectuar
+ * @return {String} String com as iteracções até n
+ */
+MathL.CMarkov.prototype.printit=function(n){
+	var itres="";
+	for(var i=0;i<n;i++){
+		this.iterate();
+		itres+=this.printIteration()+"\n";
+	}
+	return itres;
+}
+/**
+ * Método que calcula a raiz de um valor para um dado expoente com uma determinada precisão
+ * @param {Object} val Valor do valor na base
+ * @param {Object} exp Valor do expoente
+ * @param {Object} err Numere de casas de precisão
+ */
+MathL.sqrtF=function(val,exp,prec){
+	if(typeof(prec)=='undefined'){
+		prec=3;
+	}
+	var xi=val/2;
+	var xa=val;
+	var err=1/Math.pow(10,prec);
+	ALG.ITER=0;
+	while(Math.abs(xi-xa)>err){
+		xa=xi;
+		xi=xi-(Math.pow(xi,exp)-val)/(exp*xi);
+		ALG.ITER++;
+	}
+	return xi;
+};
+
+/**
+ * Método de Simpson para cálculo de integrais
+ * @param {Function} f Função que se pretende integrar
+ * @param {Number} min Minimo do intervalo de integração
+ * @param {Number} max Maximo do intervalo de integração
+ * @param {Number} n Número de intervalos
+ * @return {Number} Integral de Simpson
+ */
+MathL.SimpsonInt=function(f,min,max,n){
+	n=n*2;
+	var sint=f(min);
+	var passo=(max-min)/n;
+	var fact=0;
+	var xi;
+	for(var i=1;i<=n;i++){
+		//determina o factor para cada iteracção
+		fact=(i==n)?1:(i%2==0)?2:4;
+		xi=min+passo*i;
+		sint+=fact*f(xi);
+	}
+	return sint*(passo/3);
+}
+/**
+ * Determinação do integral da função f a partir do método do trapézio
+ * @param {Function} f Função a integrar
+ * @param {Number} min Intervalo minimo de integração
+ * @param {Number} max Intervalo máximo de integração
+ * @param {Number} n Número de intervalos para integração
+ * @return {Number} Integral de f entre min e max
+ */
+MathL.TrapzInt=function(f,min,max,n){
+	var passo=(max-min)/n;
+	var strap=f(min);
+	var fact;
+	var xi;
+	for(var i=1;i<=n;i++){
+		fact=(i==n)?1:2;
+		xi=min+passo*i;
+		strap+=fact*f(xi);
+	}
+	return strap*(passo/2);
+}
+/**
+ * Determina o integral de um intervalo de valores e respectivas imagens a partir do 
+ * algoritmo do trapézio
+ * @param {Array} arrx array de coordenadas
+ * @param {Array} arry array das imagens das coordenadas
+ */
+MathL.TrapzCInt=function(arrx,arry){
+	if(arrx.length!=arry.length)
+		return Number.NaN;
+	var soma=0;
+	for(var i=1;i<arrx.length;i++){
+		soma+=(arrx[i]-arrx[i-1])*(arry[i]+arry[i-1]);
+	}
+	return soma/2;
+}
+/**
+ * Aplica o array a uma função. O resultado consiste nas imagens obtidas a partir da aplicação
+ * da função aos elementos do array
+ * @param {Function} f Função que mapeia o array
+ * @return {Array} Array mapeado pela função f.
+ */
+Array.prototype.MapF=function(f){
+	var arro=[];
+	for(var i=0;i<this.length;i++){
+		arro[i]=f(this[i]);
+	}
+	return arro;
+}
+/***
+ * Método que cria um array com os valores entre min e máx
+ * @param {Number} min Valor mínimo do intervalo
+ * @param {Number} max Valor máximo do intervalo
+ * @param {Number} passo Passo entre os sucessivos valores
+ * @return {Array}  Array com os valores compreendidos entre min e max.
+ */
+Array.map=function(min,max,passo){
+	var ps;
+	if(passo)
+		ps=passo;
+	else
+		ps=1;
+	var out=[];
+	for(var i=0;i<max;i+=ps){
+		out[out.length]=min+i;
+	}
+	return out;
+}
+
+/**
+ * Método que determina a distância de Hamming para duas Strings 
+ * @param {String} str1 String A
+ * @param {String} str2 String B
+ * @return {Number} dist Distância entre A e B
+ */
+MathL.hammingDistance=function(str1,str2){
+	var diff=Math.abs(str1.length-str2.length);
+	var cmin=Math.min(str1.length,str2.length);
+	var hdist=diff;
+	for(var i=0;i<cmin;i++){
+		if(str1.charAt(i)!=str2.charAt(i))
+			hdist++;
+	}
+	return hdist;
+}
+
+/**
+ * Objecto matriz disponibiliza um conjunto de métodos para manipular matrizes
+ * @param {int} m Numero de linhas
+ * @param {int} n Numero de colunas
+ * @param {int} val Valor por defeito nos campos da matriz
+ * @classDescription Classe que pretende representar uma matriz
+ */
+MathL.Matriz=function(m,n,val){
+	var nlinhas=3;
+	var ncolunas=3;
+	var valdef=0;
+	if(typeof(m)!='undefined')
+		nlinhas=m;
+	if(typeof(m)!='undefined')
+		ncolunas=n;
+	if(typeof(val)!='undefined')
+		valdef=val;
+	this._initVal(nlinhas,ncolunas,valdef);
+};
+
+/**
+ * Método que devolve a matriz transposta
+ * @return {MathL.Matriz} mat Matriz transposta
+ */
+MathL.Matriz.prototype.transposta=function(){
+	var nlinhas=this._matriz.length;
+	var ncolunas=this._matriz[0].length;
+	var mt=new MathL.Matriz(ncolunas,nlinhas);
+	for(var i=0;i<nlinhas;i++){
+		for(j=0;j<ncolunas;j++){
+			mt.setValor(j,i,this.getValor(i,j));
+		}
+	}
+	return mt;
+}
+
+/**
+ * Método que devolve a submatriz excluindo a linha i e a coluna j
+ * @param {Int} i Índice da linha que se pretende excluir
+ * @param {Int} j Índice da coluna que se pretende excluir
+ * @return {MathL.Matriz} mt Matriz
+ */
+MathL.Matriz.prototype.subMatriz=function(i,j){
+	var ii=0;
+	var jj=0;
+	var ik=0;
+	var jk=0;
+	var m=new MathL.Matriz(this._matriz.length-1,this._matriz[0].length-1);
+	for(ii=0;ii<this._matriz.length;ii++){
+		jk=0;
+		if (ii != i) {
+			for (jj = 0; jj < this._matriz[0].length; jj++) {
+				if(jj!=j){
+					m.setValor(ik,jk,this._matriz[ii][jj]);
+					jk++;
+				}
+			}
+			ik++;
+		}
+	}
+	return m;
+}
+
+/**
+ * Verifica se uma dada matriz é simétrica
+ * @return {Boolean} bol Valor booleano indicando se a matriz é simétrica ou não
+ */
+MathL.Matriz.prototype.simetrica=function(){
+	if(this._matriz.length!=this._matriz[0].length){
+		return false;
+	}
+	for(var i=0;i<this._matriz.length;i++){
+		for(var j=i;j<this._matriz.length;j++){
+			if(this._matriz[j][i]!=this._matriz[i][j]){
+				return false;
+			}
+		}
+	}
+	return true;
+}
+/**
+ * Determina a matriz das covariâncias
+ * @param {Array} Um conjunto de um ou mais arrays com os valores das amostras
+ * @return {MathL.Matriz} Matriz das covariâncias
+ */
+MathL.Matriz.MCov=function(){
+	if(arguments.length==0)
+		return new MathL.Matriz(1,1,0);
+	var nargs=arguments.length;
+	var m=new MathL.Matriz(nargs,nargs,0);
+	for(var i=0;i<nargs;i++){
+		for(var j=0;j<nargs;j++){
+			m.setValor(i,j,Array.cov(arguments[i],arguments[j]));
+		}
+	}
+	return m;
+}
+
+/**
+ * * Método que inicializa a matriz com os campos assinados a um determinado valor
+ * @param {Number} valor Valor por defeito na matriz
+ * @param {Int} nlinhas Numero de linhas da matriz
+ * @param {Int} ncolunas Numero de colunas da matriz
+ */
+MathL.Matriz.prototype._initVal=function(nlinhas,ncolunas,valor){
+	this._matriz=[];
+	for(var i=0;i<nlinhas;i++){
+		this._matriz[i]=[];
+		for(var j=0;j<ncolunas;j++){
+			this._matriz[i][j]=valor;
+		}
+	}
+};
+
+/**
+ * Devolve uma string com a descrição da matriz
+ * @return {String} String representando a matriz
+ */
+MathL.Matriz.prototype.toString=function(){
+	var strO="";
+	for(var i=0;i<this._matriz.length;i++){
+		strO+="\n|";
+		for(var j=0;j<this._matriz[i].length;j++){
+			strO+=this._matriz[i][j];
+			if(j!=this._matriz[i].length-1)
+				strO+=",";
+		}
+		strO+="|";
+	}
+	return strO;
+};
+
+/**
+ * Método que efectua o parsing de um array bidimensional para a estrutura de Matriz
+ * @param {array} array Array bidimensional contendo os valores da matriz
+ * @return {MathL.Matriz} matriz Objecto do tipo matriz com os valores existentes no array
+ */
+MathL.Matriz.fromArray=function(array){
+	var m=new MathL.Matriz(array.length,array[0].length);
+	for(var i=0;i<array.length;i++){
+		for(var j=0;j<array[0].length;j++){
+			m.setValor(i,j,array[i][j]);
+		}
+	}
+	return m;
+};
+/**
+ * Método que cria um objecto matriz a partir de um array
+ * @param {Number} dimx Número de linhas
+ * @param {Number} dimy Número de colunas
+ * @param {Array} arr Com os valores da matriz sob a forma de array
+ * @return {MathL.Matriz} Matriz 
+ */
+MathL.Matriz.ArrayToMatriz=function(dimx,dimy,arr){
+	var mout=new MathL.Matriz(dimx,dimy,0);
+	for(var i=0;i<dimx;i++){
+		for(var j=0;j<dimy;j++){
+			mout.setValor(i,j,arr[i*dimy+j]);
+		}
+	}
+	return mout;
+}
+
+/**
+ * Método que especifica o valor da matriz na posição (i,j)
+ * @param {int} i Indice de linha
+ * @param {int} j Indice de coluna
+ * @param {Number} val Valor da celula
+ */
+MathL.Matriz.prototype.setValor=function(i,j,val){
+	this._matriz[i][j]=val;
+};
+
+/**
+ * Método que devolve o valor da matriz na posicao (i,j)
+ * @param {int} i Indice de linha
+ * @param {int} j Indice de coluna
+ * @return {Number} Valor da matriz na celula especificada
+ */
+MathL.Matriz.prototype.getValor=function(i,j){
+	return this._matriz[i][j];
+};
+
+/**
+ * Método que devolve uma linha da matriz sob a forma de array
+ * @param {int} indice Indice da linha
+ * @return {array} Array contendo os valores de uma determinada linha
+ */
+MathL.Matriz.prototype.getLinha=function(indice){
+	var arrL=[];
+	for(var i=0;i<this._matriz[indice].length;i++){
+		arrL[i]=this.getValor(indice,i);
+	}
+	return arrL;
+};
+
+/**
+ * Método que efectua a troca entre duas linhas da matriz
+ * @param {int} i Índice de linha
+ * @param {int} j Índice de linha
+ * @return{MathL.Matriz} mat Devolve a matriz para permitir chaining
+ */
+MathL.Matriz.prototype.trocaLinhas=function(i,j){
+	var ii=0;
+	var aux;
+	var comp=this._matriz[0].length;
+	for(ii=0;ii<comp;ii++)
+	{
+		aux=this._matriz[i][ii];
+		this._matriz[i][ii]=this._matriz[j][ii];
+		this._matriz[j][ii]=aux;
+	}
+	return this;
+}
+
+/**
+ * Método que efectua a troca entre duas colunas da matriz
+ * @param {int} i Índice de coluna
+ * @param {int} j Índice de coluna
+ * @return{MathL.Matriz} mat Devolve a matriz para permitir chaining
+ */
+MathL.Matriz.prototype.trocaColunas=function(i,j){
+	var ii=0;
+	var aux;
+	var comp=this._matriz.length;
+	for(ii=0;ii<comp;ii++)
+	{
+		aux=this._matriz[ii][i];
+		this._matriz[ii][i]=this._matriz[ii][j];
+		this._matriz[ii][j]=aux;
+	}
+	return this;
+}
+
+/**
+ * Método que adiciona uma coluna à matriz
+ * @param  {Array} arr Array com os valores da coluna que se pretende adicionar
+ * @return {MathL.Matriz} Devolve o próprio objecto para efeitos de chaining
+ */
+MathL.Matriz.prototype.adColuna=function(arr){
+	if(arr.length!=this._matriz.length){
+		return this;
+	}
+	var coln=this._matriz[0].length;
+	for(var i=0;i<this._matriz.length;i++){
+		this._matriz[i][coln]=arr[i];
+	}
+}
+
+/**
+ * Método que adiciona linhas à Matriz
+ * @param {Array} arr Array com os valores da linha que se pretende adicionar à matriz
+ * @return {MathL.Matriz} obj Devolve o próprio objecto para efeitos de chaining
+ */
+MathL.Matriz.prototype.adLinha=function(arr){
+	if(arr.length!=this._matriz[0].length){
+		return this;
+	}
+	var linc=this._matriz.length;
+	this._matriz[linc]=[];
+	for(var i=0;i<linc;i++){
+		this._matriz[linc][i]=arr[i];
+	}
+}
+
+/**
+ * Método que remove uma linha da matriz
+ * @param {int} ind indice da linha da matriz que pretendemos ver removido
+ * @return {MathL.Matriz} mat O proprio objecto matriz, para chaining
+ */
+MathL.Matriz.prototype.rmLinha=function(ind){
+	if(ind<0 || ind >=this._matriz.length){
+		return this;
+	}
+	this._matriz.remove(ind);
+	return this;
+};
+
+/**
+ * Método que remove uma coluna da matriz
+ * @param {Int} ind Índice da matriz que pretendemos remover
+ * @return {MathL.Matriz} mat O próprio objecto matriz, para chaining
+ */ 
+MathL.Matriz.prototype.rmColuna=function(ind){
+	if(ind<0 || ind >=this._matriz[0].length){
+		return this;
+	}
+	for(var i=0;i<this._matriz[0].length;i++){
+		this._matriz[i].remove(ind);
+	}
+	return this;
+}
+
+/**
+ * Método que devolve uma coluna da matriz sob a forma de array
+ * @param {int} indice Índice da coluna
+ * @return {array} Array contendo os valores de uma determinada coluna
+ */
+MathL.Matriz.prototype.getColuna=function(indice){
+	var arrC=[]
+	for(var i=0;i<this._matriz.length;i++){
+		arrC[i]=this._matriz[i][indice];
+	}
+	return arrC;
+};
+
+/**
+ * Método que cria uma matriz quadrada identidade de dimensões (nxn)
+ * @param {int} n Número de linhas
+ * @param {int} m Número de colunas
+ * @return {MathL.Matriz} Matriz identidade
+ */
+MathL.Matriz.identidade=function(n,m){
+	if(typeof(m)=='undefined')
+		m=n;
+	var m=new MathL.Matriz(n,m,0);
+	for(var i=0;i<n;i++){
+		m.setValor(i,i,1);
+	}
+	return m;
+};
+
+/**
+ * Método que multiplica uma linha por um determinado valor
+ * @param {Int} ind Índice da linha
+ * @param {Number} val Valor pelo qual se pretende multiplicar uma linha da matriz
+ * @return {MathL.Matriz} mat Objecto para efeitos chaining
+ */
+MathL.Matriz.prototype.MLinha=function(ind,val){
+	if(ind<0 || ind>this._matriz.length){
+		return null;
+	}
+	var ncol=this._matriz[0].length;
+	for(var i=0;i<ncol;i++){
+		this._matriz[ind][i]*=val;
+	}
+	return this;
+}
+
+MathL.Matriz.prototype.MColuna=function(ind,val){
+	if(i<0 || i>this._matriz[0].length){
+		return this;
+	}
+	var nlin=this._matriz.length;
+	for(var i=0;i<nlin;i++){
+		this._matriz[i][ind]*=val;
+	}
+	return this;
+}
+
+/**
+ * Método que adiciona valores a uma linha da matriz
+ * @param {Int} ind Índice da linha
+ * @param {Array} arrV Array contendo os valores que se pretendem adicionar à matriz
+ * @return {MathL.Matriz} mat O próprio objecto para efeitos de chaining
+ */
+MathL.Matriz.prototype.AddToLinha=function(ind,arrV){
+	var ncol=this._matriz[0].length;
+	if(arrV.length!=ncol){
+		return this;
+	}
+	for(var i=0;i<ncol;i++){
+		this._matriz[ind][i]+=arrV[i];
+	}
+	return this;
+}
+
+/**
+ * Método que adiciona valores a uma coluna da matriz
+ * @param {Int} ind Índice da coluna
+ * @param {Array} arrV Array com os valores a adicionar à coluna
+ * @return {MathL.Matriz} mat O próprio objecto para efeitos de chaining
+ */
+MathL.Matriz.prototype.AddToColuna=function(ind,arrV){
+	var nlin=this._matriz.length;
+	if(arrV.length!=nlin){
+		return this;
+	}
+	for(var i=0;i<ncol;i++){
+		this._matriz[i][ind]+=arrV[i];
+	}
+	return this;
+}
+
+
+/**
+ * Método que efectua a multiplicação de duas matrizes A, B
+ * @param {MathL.Matriz} mat1 Matriz A
+ * @param {MathL.Matriz} mat2 Matriz B
+ * @return {MathL.Matriz} mat3 O resultado da multiplicação das matrizes A,B
+ */
+MathL.Matriz.multMatriz=function(mat1,mat2){
+	if(mat1._matriz[0].length!=mat2._matriz.length)
+		return null;
+	var ma=new MathL.Matriz(mat1._matriz.length,mat2._matriz[0].length,0);
+	var valcel=0;
+	for(var i=0;i<mat2._matriz[0].length;i++){
+		for(var j=0;j<mat1._matriz.length;j++){
+			valcel=0;
+			for(var k=0;k<mat1._matriz[0].length;k++){
+				valcel+=mat1._matriz[j][k]*mat2._matriz[k][i];
+			}
+			ma.setValor(j,i,valcel);
+		}
+	}
+	return ma;
+};
+
+/**
+ * Método que efectua a redução da matriz a triangular inferior
+ * @return {MathL.Matriz} mat Devolve a matriz triangular inferior a partir do processo de Gauss Jordan
+ */
+MathL.Matriz.prototype.RTriangular=function(){
+	var k=0;
+	var i=0;
+	var j=0;
+	var laux;
+	var colmax=0;
+	var nlinhas=this._matriz.length;
+	var ncolunas=this._matriz[0].length;
+	var inv=MathL.Matriz.identidade(nlinhas,ncolunas);
+	var mac=this.clone();
+	var auxP;
+	//Iteracção sobre as colunas
+	for(i=0;i<ncolunas;i++){
+		if (i < nlinhas) {
+			//Procura a linha com o valor maximo para a dada coluna
+			linmax = i;
+			for (k = i; k < nlinhas; k++) {
+				if (mac._matriz[linmax][i] < mac._matriz[k][i]) {
+					linmax = k;
+				}
+			}
+			mac.trocaLinhas(i,linmax);
+			//Actualiza as linhas
+			for(j=0;j<mac._matriz.length;j++){
+				if (j != i) {
+					auxP=mac._matriz[j][i];
+					//actualiza os valores da linha
+					for(k=i;k<mac._matriz[0].length;k++){
+						mac._matriz[j][k]+=-mac._matriz[i][k]*(auxP/mac._matriz[i][i]);
+					}
+				}
+			}
+		}
+	}
+	return mac;
+}
+
+/**
+ * Método que resolve um sistema de equações lineares a partir do algoritmo de eliminação de Gauss
+ * @param {MathL.Matriz} mat Matriz de coeficientes
+ * @return {MathL.Matriz} matsol Matriz solução do sistema
+ */
+MathL.Matriz.ResolveSistema=function(mat){
+	var ms=mat.RTriangular();
+	var j;
+	var k;
+	var aux;
+	var i;
+	for(i=ms._matriz.length-1;i>=0;i--){
+		if(ms._matriz[i][i]!=0){
+			ms.MLinha(i,1/ms._matriz[i][i]);
+			for(j=i-1;j>=0;j--){
+				aux=ms._matriz[j][i];
+				for(k=i;k<ms._matriz[0].length;k++){
+					ms._matriz[j][k]+=-ms._matriz[j][k]*(aux/ms._matriz[i][i]);
+				}
+			}
+		}
+	}
+	var so="{";
+	var nlinhas=ms._matriz.length;
+	var ncolunas=ms._matriz[0].length;
+	var sol;
+	for(var i=0;i<ms._matriz.length;i++){
+		if (ms._matriz[i][i] != 0) {
+			sol = ms._matriz[i][ncolunas - 1] / ms._matriz[i][i];
+		}
+		else{
+			sol=0;
+		}
+		if(i==0){
+			so+='"x'+i+'":'+sol;
+		}
+		else{
+			so+=',"x'+i+'":'+sol;
+		}
+		
+	}
+	so+="}";
+	return eval('('+so+')');
+}
+
+/**
+ * Método que devolve a factorização LU da matriz
+ * @return {Object} obj Objecto composto por duas matrizes L e U representando
+ * a factorização da matriz contida no objecto que efectua a chamada da função.
+ */
+MathL.Matriz.prototype.FactLU=function(){
+	var k=0;
+	var i=0;
+	var j=0;
+	var laux;
+	var colmax=0;
+	var nlinhas=this._matriz.length;
+	var ncolunas=this._matriz[0].length;
+	var inv=MathL.Matriz.identidade(nlinhas,ncolunas);
+	var U=this.clone();
+	var L=MathL.Matriz.identidade(nlinhas,ncolunas);
+	var auxP;
+	//Iteracção sobre as colunas
+	for(i=0;i<ncolunas;i++){
+		if (i < nlinhas) {
+			//Actualiza as linhas
+			for(j=0;j<U._matriz.length;j++){
+				if (j != i) {
+					auxP=U._matriz[j][i];
+					//actualiza os valores da linha
+					for(k=i;k<U._matriz[0].length;k++){
+						U._matriz[j][k]+=-U._matriz[i][k]*(auxP/U._matriz[i][i]);
+						L._matriz[j][k]+=-U._matriz[i][k]*(auxP/U._matriz[i][i]);
+					}
+				}
+			}
+		}
+	}
+	var obj={"L":L,"U":U};
+	return obj;
+}
+
+/**
+ * Método que multiplica a matriz por um determinado valor escalar
+ * @param {Number} val Escalar
+ * @return {MathL.Matriz} Matriz Devolve a propria matriz para possibilitar o chaining na invocacao
+ * dos Métodos
+ */
+MathL.Matriz.prototype.multEscalar=function(val){
+	for(var i=0;i<this._matriz.length;i++)
+		for(var j=0;j<this._matriz[0].length;j++)
+			this._matriz[i][j]*=val;
+	return this;
+};
+
+/**
+ * Método que efectua o clone do objecto matriz
+ * @return {MathL.Matriz} A cópia do objecto matriz
+ */
+MathL.Matriz.prototype.clone=function(){
+	return MathL.Matriz.fromArray(this._matriz);
+};
+
+/**
+ * Construtor do objecto Vector2D.
+ * @param {double} vx
+ * @param {double} vy
+ * @classDescription Este objecto implementa um objecto que representa vectores de duas dimensões,
+ * utilizado para computar operações gráficas no plano
+ */
+MathL.Vector2D=function(vx,vy){
+	this.x=vx;
+	this.y=vy;
+};
+
+/**
+ * Método que faz uma copia do objecto
+ * @return {MathL.Vector2D} Objecto do tipo Vectord2D
+ */
+MathL.Vector2D.prototype.clone=function(){
+	return new MathL.Vector2D(this.x,this.y);
+};
+
+MathL.Vector2D.prototype.toString=function(){
+	return "["+this.x+","+this.y+"]";
+}
+
+/**
+ * Método que multiplica o vector por um escalar
+ * @param {Double} esc Número escalar
+ * @return {Vector2D} vec Devolve o próprio vector para permitir chaining
+ */
+MathL.Vector2D.prototype.multEscalar=function(esc){
+	this.x*=esc;
+	this.y*=esc;
+	return this;
+};
+
+/**
+ * Método que soma dois vectores
+ * @param {MathL.Vector2D} vecA Primeiro Vector2D 
+ * @param {MathL.Vector2d} vecB Segundo Vector2D
+ * @return {MathL.Vector2D} vecR Vector2D soma resultante
+ */
+MathL.Vector2D.somaVec=function(vecA,vecB){
+	return new MathL.Vector2D(vecA.x+vecB.x,vecA.y+vecB.y);
+};
+/**
+ * Método que efectua o produto interno entre dois vectores 
+ * @param {MathL.Vector2D} vecA Primeiro Vector2D
+ * @param {MathL.Vector2D} vecB Segundo Vector2D
+ * @return {Double} prodint Número representando o produto interno entre dois vectores
+ */
+MathL.Vector2D.prodInt=function(vecA,vecB){
+	return vecA.x*vecB.x+vecA.y*vecB.y;
+};
+
+/**
+ * Método que devolve a norma de um Vector2D
+ * @return {double} num Norma do vector
+ */
+MathL.Vector2D.prototype.norma=function(){
+	return Math.sqrt(this.x*this.x+this.y*this.y);
+};
+/**
+ * Devolve informação sobre o vector sob a forma de string
+ * @return {string} str String contendo a descrição do vector
+ */
+MathL.Vector2D.prototype.toString=function(){
+	return "["+this.x+","+this.y+"]";
+};
+
+
+
+/**
+ * Método que devolve o objecto Matriz equivalente ao Vector2D
+ * @return {MathL.Matriz}
+ */
+MathL.Vector2D.prototype.toMatriz=function(){
+var vm=new MathL.Matriz(1,2);
+vm.setValor(0,0,this.x);
+vm.setValor(0,1,this.y);
+return vm;	
+};
+
+/**
+ * Máximo divisor comum a partir do algoritmo de euclides
+ * @param {int} a Valor inteiro A
+ * @param {int} b Valor inteiro B
+ * @return {int} O máximo divisor entre A e B
+ */
+MathL.mdc=function(a,b){
+	ALG.ITER=0;
+	if(a==0)
+		return b;
+	if(b==0)
+		return a;
+	var ax=Math.max(a,b);
+	var bx=Math.min(a,b);
+	var m=0;
+	if((ax%bx)==0)
+		return bx;
+	//algoritmo de euclides...
+	while(bx!=0){
+		ALG.ITER++;
+		m=ax%bx;
+		ax=bx;
+		bx=m;
+	}
+	return ax;
+};
+
+/**
+ * Função para o factorial de um numero
+ * @param {int} a Numero inteiro
+ * @return {int} Factorial de um número
+ */
+MathL.factorial=function(a){
+	var b=Math.abs(a);
+	var fact=1;
+	for(var i=1;i<=b;i++)
+		fact*=i;
+	return fact;
+};
+
+/**
+ * Método que devolve os primos existentes menor que um dado numero n
+ * @param {int} n Número máximo dos valores primos
+ * @return {Array} Array contendo os valores primos
+ */
+MathL.PrimosAte=function(n){
+	var primos=[1,2];
+	var primo;
+	for(i=3;i<=n;i++){
+		primo=true;
+		for(j=1;j<primos.length;j++){
+			if(primos[j]>Math.sqrt(i))
+				break;
+			if((i%primos[j])==0)
+				primo=false;
+		}
+		if(primo)
+			primos[primos.length]=i;
+	}
+	return primos;
+};
+
+/**
+ * Determina a média dos valores contidos no array, aqui assume-se que o array 
+ * é preenchido com valores numéricos
+ */
+Array.prototype.media=function(){
+	var cmp=this.length;
+	var m=0;
+	for(var i=0;i<cmp;i++)
+		m+=this[i];
+	return m/cmp;
+}
+
+/**
+ * Determina a variância dos valores contidos no array
+ * @return {Number}
+ */
+Array.prototype.variancia=function(){
+	if(this.length<2)
+		return 0;	
+	var cmp=this.length;
+	var dp=0;
+	var md=this.media();
+	for(var i=0;i<cmp;i++){
+		dp+=(this[i]-md)*(this[i]-md);
+	}
+	return dp/(cmp-1);
+}
+/**
+ * Determina o desvio padrão dos dados contidos no array
+ * @return {Number}
+ */
+Array.prototype.desPad=function(){
+	return Math.sqrt(this.variancia());
+}
+
+/**
+ * Determina a covariância entre duas amostras representadas sob a forma de 
+ * arrays. As duas amostras devem ter a mesma dimensão
+ * @param {Array} X Array de valores numéricos
+ * @param {Array} Y Array de valores numéricos
+ * @return {Number} Valor da covariância entre a amostra X e a amostra Y
+ */
+Array.cov=function(X,Y){
+	if(X.length!=Y.length)
+		return 0;
+	if(X.length<2)
+		return 0;
+	var cmp=X.length;
+	var xM=X.media();
+	var yM=Y.media();
+	var c=0;
+	for(var i=0;i<cmp;i++){
+		c+=(X[i]-xM)*(Y[i]-yM);
+	}
+	return c/(X.length-1);
+}
+
+Array.prototype.soma=function(){
+	var s=0;
+	var cmp=this.length;
+	for(var i=0;i<cmp;i++){
+		s+=this[i];
+	}
+	return s;
+}
+
+Array.sub=function(arrA,arrB){
+	var mx=Object.max(arrA,arrB);
+	var mi=Object.max(arrA,arrB);
+	var out=[];
+	for(var i=0;i<mx.length;i++){
+		if(i<mi.length)
+			out[out.length]=arrA[i]-arrB[i];
+		else{
+			if(arrA[i])
+				out[out.length]=arrA[i];
+			else
+				out[out.length]=-arrB[i];
+		}
+	}
+	return out;
+}
+
+Array.prototype.clona=function(){
+	var cmp=this.length;
+	var out=[];
+	for(var i=0;i<cmp;i++)
+		out[out.length]=this[i];
+	return out;
+}
+
+Array.prototype.subE=function(esc){
+	var cmp=this.length;
+	for(var i=0;i<cmp;i++){
+		this[i]=this[i]-esc;
+	}
+	return this;
+}
+
+Array.prototype.somaE=function(esc){
+	var cmp=this.length;
+	for(var i=0;i<cmp;i++){
+		this[i]=this[i]-esc;
+	}
+	return this;
+}
+
+Array.soma=function(arrA,arrB){
+	var mx=Object.max(arrA,arrB);
+	var mi=Object.max(arrA,arrB);
+	var out=[];
+	for(var i=0;i<mx.length;i++){
+		if(i<mi.length)
+			out[out.length]=arrA[i]+arrB[i];
+		else{
+			if(arrA[i])
+				out[out.length]=arrA[i];
+			else
+				out[out.length]=arrB[i];
+		}
+	}
+	return out;
+}
+
+
+
+/**
+ * Método que devolve os primeiros n primos
+ * @param {int} n Numero de primos que pretendemos ver devolvidos
+ * @return {Array} arrayPrimos Array com os numeros primos
+ */
+MathL.PPrimos = function(n){
+	if (typeof(n) == 'undefined') 
+		n = 20;
+	var primos = [1, 2];
+	var primo;
+	var i=3;
+	ALG.ITER=0;
+	while (primos.length < n) {
+		primo = true;
+		for (j = 1; j < primos.length; j++) {
+			if (primos[j] > Math.sqrt(i)) 
+				break;
+			if ((i % primos[j]) == 0) 
+				primo = false;
+			ALG.ITER++;
+		}
+		if (primo) 
+			primos[primos.length] = i;
+		i++;
+	}
+	return primos;
+};
+
+/**
+ * Método que devolve o valor de combinações (n,k)
+ * @param {int} n Inteiro (n k) --> n
+ * @param {int} k Inteiro (n k) --> k
+ * @return {int} com Inteiro número de combinações 
+ */
+MathL.comb=function(n,k){
+	var res=1;
+	for(var i=1;i<=k;i++){
+		res*=(n+1-i)/i;
+	}
+	return res;
+};
+
+
+
+var COOkie={};
+
+COOkie.setCookie=function(cookieName,cookieValue,minutos) {
+ var today = new Date();
+ var expire = new Date();
+ if (minutos==null || minutos==0) minutos=1;
+ expire.setTime(today.getTime() + 60000*minutos);
+ document.cookie = cookieName+"="+escape(cookieValue)
+                 + ";expires="+expire.toGMTString();
+};
+
+
+var Crypto=function(){
+};
+/**
+ * Função que implementa a criptografia de Ceaser
+ * @param {string} str string a criptografar
+ * @param {int} shift Número de deslocamentos
+ * @return {string} strC String criptografada
+ */
+Crypto.cesar=function(str,shift){
+	var i;
+	var strO="";
+	var chcod;
+	for(i=0;i<str.length;i++){
+		if (str.charAt(i) != " ") {
+			chcod = str.charCodeAt(i);
+			strO += String.fromCharCode(chcod + shift);
+		}
+		else
+			strO+=" ";
+	}
+	return strO;
+};
+
+/**
+ * Método que gera uma chave aleatória de vigénere
+ * @param {Int} comp Comprimento da chave
+ * @return {String} str A string que representa a chave para o algoritmo de vigénere
+ */
+Crypto.vigenereRandomKey=function(comp){
+	var str="";
+	if(typeof(comp)=='undefined'){
+		comp=10;
+	}
+	for(var i=0;i<comp;i++){
+		str+=String.fromCharCode(Math.floor(Math.random()*26 + 65));
+	}
+	return str;
+}
+
+Crypto.Hash={};
+
+Crypto.Hash.md5=function(str){
+	this.senc=str;
+};
+
+
+
+/**
+ * Criptanalise à cifra de cesar a partir de força bruta
+ * @param {String} str string a ser decriptada
+ * @param {int} maxiter Maximo de iterações
+ * @return {String} strO String contendo as várias tentativas de decriptação a partir de força bruta
+ */
+Crypto.cesarBruteForceAttack=function(str,maxiter){
+	var i;
+	var iter=0;
+	var strO="";
+	while (iter < maxiter) {
+		strO+="\n";
+		for (i = 0; i < str.length; i++) {
+			strO+=String.fromCharCode(str.charCodeAt(i)-iter);
+		}
+		iter++;
+	}
+	return strO;
+};
+
+/**
+ * Ataque por frequências
+ * @param {string} str String que se pretende inspeccionar
+ * @return {String} strO string contendo a informação sobre as frequências dos vários caracteress
+ */
+Crypto.frequenceAttack=function(str){
+	var tbfreq=[];
+	var pos;
+	var i;
+	var strO="";
+	var existeCar=function(car){
+		var existe=-1;
+		for(var i=0;i<tbfreq.length;i++){
+			if(car==tbfreq[i][0])
+				existe=i;
+		}
+		return existe;
+	};
+	//calcula as frequencias
+	for(i=0;i<str.length;i++){
+		pos=existeCar(str.charAt(i));
+		if(pos==-1){
+			tbfreq[tbfreq.length]=[str.charAt(i),1];
+		}
+		else{
+			tbfreq[pos][1]++;
+		}
+	}
+	//devolve os resultados
+	var freq=0;
+	for(i=0;i<tbfreq.length;i++){
+		freq=(tbfreq[i][1]*100)/str.length;
+		strO+="\n";
+		strO+="Car:|"+tbfreq[i][0]+"|--> "+freq+"%";
+	}
+	return strO;
+};
+
+/**
+ * Método que encripta uma string a partir da chave de Vigénere. Este método encripta somente
+ * strings que contenham caracteres do alfabeto
+ * @param {String} str String a encriptar 
+ * @param {String} chave Chave encriptadora
+ * @return {String} enc Chave encriptada a partir do algoritmo de vigénere
+ * 
+ */
+Crypto.VEncripta=function(str,chave){
+	if(typeof(chave)=='undefined'){
+		chave=Crypto.vigenereRandomKey();
+		ALG.VIGSECRETKEY=chave;
+	}
+	else{
+		chave=chave.toMaiuscula();
+		ALG.VIGSECRETKEY=chave;
+	}
+	//Se a string a codificar não for válida sai com valor nulo
+	if(!String.isAlphaChar(str)){
+		return null;
+	}
+	var chcomp=chave.length;
+	var chcod=0;
+	var deslocamentochave=0;
+	var strOut="";
+	var offset=0;
+	var k=0;
+	str=str.toMaiuscula();
+	for(var i=0;i<str.length;i++){
+		if (str.charCodeAt(i) == 32) {
+			strOut+=" ";
+		}
+		else {
+			deslocamentochave = k % chcomp;
+			chchave = chave.charCodeAt(deslocamentochave) - 65;
+			chcod = str.charCodeAt(i) - 65;
+			offset = (chcod + chchave) % 26;
+			strOut += String.fromCharCode(65 + offset);
+			k++;
+		}
+	}
+	return strOut;
+}
+
+/**
+ * Método que efectua a desencriptação de uma string codificada a partir do algoritmo de Vigénere
+ * @param {String} stre String codificada
+ * @param {String} chave Chave de encriptação
+ * @return {String} strd String descodificada
+ */
+Crypto.VDecripta=function(str,chave){
+	if(typeof(chave)=='undefined'){
+		chave=ALG.VIGSECRETKEY;
+	}
+	else{
+		chave=chave.toMaiuscula();
+	}
+	var chcomp=chave.length;
+	var chcod=0;
+	var deslocamentochave=0;
+	var strOut="";
+	var offset=0;
+	var k=0;
+	str=str.toMaiuscula();
+	for(var i=0;i<str.length;i++){
+		if (str.charCodeAt(i) == 32) {
+			strOut+=" ";
+		}
+		else {
+			deslocamentochave = k % chcomp;
+			chchave = chave.charCodeAt(deslocamentochave) - 65;
+			chcod = str.charCodeAt(i) - 65;
+			offset =(chcod - chchave) % 26;
+			if(offset<0)
+				offset=26+offset;
+			strOut += String.fromCharCode(65 + offset);
+			k++;
+		}
+	}
+	return strOut;
+}
+
+/**
+ * @constructor Namspace que representa os algoritmos de compressão de dados
+ */
+var Compressao=function(){};
+
+Compressao.HuffmanEncodingTree=function(str){
+	//Transforma o objecto de frequências em num array dicionario
+	var strO=Utils.charFreq(str);
+	var arrO=strO.toDicArray();
+	var arrA=[];
+	var indA1;
+	var indA2;
+	var noAux1;
+	var noAux2;
+	var noRaiz;
+	//Função que detecta o elemento com valor mínimo e devolve o seu índice do array de árvores
+	var getIndMinFreqObj=function(arrA){
+		if(arrA.length==0){
+				return null;
+			}
+		var k=0;
+		for(var ii=0;ii<arrA.length;ii++){
+			if(arrA[k].key>arrA[ii]){
+				k=ii;
+			}
+		}
+		return k;
+	};
+	
+	//Criar os nós para cada um dos valores
+	for(var i=0;i<arrO.length;i++){
+		if (typeof(arrO[i][1]) == 'number') {
+			arrA[i] = new noarvore(arrO[i][1], arrO[i][0]);
+		}
+	}
+	if(arrA.length==1){
+		noRaiz=new noarvore(1,null);
+		noRaiz.esq=arrA[0];
+		return noRaiz;
+	}
+	//Fundir as árvores até só sobrar uma no array de árvores
+	while(arrA.length>1){
+		indA1=getIndMinFreqObj(arrA);
+		noAux1=arrA[indA1];
+		arrA.remove(indA1);
+		indA2=getIndMinFreqObj(arrA);
+		noAux2=arrA[indA2];
+		arrA.remove(indA2);
+		noRaiz=new noarvore(noAux1.key+noAux2.key,null);
+		noRaiz.esq=noAux1;
+		noRaiz.dir=noAux2;
+		arrA[arrA.length]=noRaiz;
+	}
+	return noRaiz;
+};
+
+/**
+ * Método que devolve os códigos dos caracteres a partir da árvore de códigos
+ * @param {noarvore} arvore Árvore contendo a codificação dos caracteres a partir do algoritmo de Huffman
+ * @param {Object} obj Objecto do tipo dicionário que irá conter os códigos de cada um dos caracteres presentes na
+ * arvore de Huffman
+ * @param {Object} str String que será sempre inicializada a vazio, necessária para recorrencia
+ */
+Compressao.getTreeCodes = function(arvore,obj,str){
+	if (arvore != null) {
+		Compressao.getTreeCodes(arvore.esq,obj,str+"1");
+		Compressao.getTreeCodes(arvore.dir,obj,str+"0");
+		if (arvore.val != null) {
+			obj[arvore.val] = str;
+		}
+	}
+	return obj;
+}
+
+/**
+ * Algoritmo de Huffman para compressão de dados
+ * @param {Object} Obj Objecto representando a árvore de huffman necessária para a compressão e descompressão dos dados
+ */
+Compressao.HuffmanEncoding=function(str){
+	var arv=Compressao.HuffmanEncodingTree(str);
+	var objC=Compressao.getTreeCodes(arv,new Object(),"");
+	var strO="";
+	var cod="";
+	for(var i=0;i<str.length;i++){
+		strO+=objC[str[i]];
+	}
+	return strO;
+};
+
+/**
+ * @constructor Class que contém um conjunto de funções utilitárias
+ */
+var Utils=function(){};
+
+Utils.prototype.ghost=function(){};
+
+/**
+ * Método que cria um objecto do tipo dicionário contendo os caracteres da string dada como entrada
+ * @param {String} str 
+ * @return {Object} obj Objecto do tipo dicionário contendo os caracteres presentes na string e a correspondente
+ * frequência associada.
+ */
+Utils.charFreq=function(str){
+	var objfr=new Object();
+	var comp=str.length;
+	for(var i=0;i<comp;i++){
+		if (typeof(objfr[str.charAt(i)]) == "undefined") {
+			objfr[str[i]] = 1 / comp;
+		}
+		else {
+			objfr[str[i]]+=1/comp;
+		}
+	}
+	return objfr;
+};
+
+/**
+ * @constructor Construtor do objecto autómato
+ * @param {Number} nest Número de estados 
+ * @param {Array} alf Array de letras que representam o alfabeto do autómato 
+ */
+var Automato=function(nest,alf){
+	this.estados=Array.map(1,nest);
+	this.transicoes=[];
+	this.finais=[];
+	this.iniciais=[];
+	this.alfabeto=alf;
+};
+/**
+ * Método que adiciona uma transição no autómato
+ * @param {Number} esta Numero do estado
+ * @param {Number} estb Numero do estado
+ * @param {Object} letra
+ */
+Automato.prototype.atrans=function(esta,estb,letra){
+	this.transicoes[this.transicoes.length]=[esta,estb,letra];
+};
+
+/**
+ * Método que devolve o automato minimo a partir de um conjunto de classes de equivalencia
+ * @private
+ * @param {Array} gclass Array de classes de estados
+ */
+Automato.prototype._gmin=function(gclass){
+	var amin=new Automato(gclass.length,this.alfabeto.clona());
+	var ef;
+	for(var i=0;i<gclass.length;i++){
+		for(var j=0;j<this.alfabeto.length;j++){
+			ef=this.trans(gclass[i][0],this.alfabeto[j]);
+			console.log(ef);
+			if(ef!=-1)
+				amin.atrans(i+1,gclass.classpos(ef)+1,this.alfabeto[j]);
+		}
+	}
+	amin.iniciais=this._iniciais(gclass);
+	amin.finais=this._finais(gclass);
+	return amin;
+};
+
+/**
+ * Devolve a classe de equivalencia inicial
+ * @param {Array} gclass Classes de estados
+ */
+Automato.prototype._iniciais=function(gclass){
+	var out=[];
+	for(var i=0;i<gclass.length;i++){
+		if(gclass[i].less(this.iniciais).length!=gclass[i].length)
+			out[out.length]=i+1;
+	}
+	return out;
+}
+
+/**
+ * Devolve as classes de estados finais
+ * @param {Array} gclass Classes de estados
+ */
+Automato.prototype._finais=function(gclass){
+	var out=[];
+	for(var i=0;i<gclass.length;i++){
+		if(gclass[i].less(this.finais).length!=gclass[i].length)
+			out[out.length]=i+1;
+	}
+	return out;
+}
+
+/**
+ * Calcula o automato mínimo. Assume-se que o autómato é um AFD
+ * @return {Automato} Objecto automato mínimo
+ */
+Automato.prototype.minimo=function(){
+	var i=this.iniciais.clona();
+	var f=this.finais.clona();
+	var nf=this.estados.less(this.finais);
+	var e1=Array.produto(nf,nf).concat(Array.produto(this.finais,this.finais));
+	var e2=Array.produto(this.estados,this.estados);
+	while(e1.length!=e2.length){
+		e2=e1.clona();
+		for(var i=0;i<e1.length;i++){
+			for(var j=0;j<this.alfabeto.length;j++){
+				if(this.trans(e1[i][0],this.alfabeto[j])!=this.trans(e1[i][1],this.alfabeto[j]))
+					e1.remove(i);
+			}
+		}
+	}
+	cl=e1.groupclasses();
+	return this._gmin(cl);
+};
+
+
+/**
+ * Devolve o estado transitado
+ * @param {Number} estado Estado
+ * @param {Object} letra Letra do alfabeto
+ * @return {Number} numero do estado transitado, -1 caso não haja transição possivel
+ */
+Automato.prototype.trans=function(estado,letra){
+	for(var i=0;i<this.transicoes.length;i++){
+		if(this.transicoes[i][0]===estado && this.transicoes[i][2]===letra)
+			return this.transicoes[i][1];
+	}
+	return -1;
+}
+
+/***
+ * Atribui final ou nao final a um estado
+ * @param {Number} esta Estado
+ * @param {Boolean} bool true-> final, false-> nao final
+ */
+Automato.prototype.sfinal=function(esta,bool){
+	var b;
+	if(typeof(bool)!='undefined')
+		b=bool;
+	else
+		b=true;
+	if(b){
+		if(this.finais.has(esta))
+			return;
+		this.finais[this.finais.length]=esta;
+	}
+	else{
+		if(!this.finais.has(esta))
+			return;
+		this.finais.remove(this.finais.pos(esta));
+	}
+};
+
+/***
+ * Atribui final ou nao inicial a um estado
+ * @param {Number} esta Estado
+ * @param {Boolean} bool true-> inicial, false-> nao inicial
+ */
+Automato.prototype.sinicial=function(esta,bool){
+	var b;
+	if(typeof(bool)!='undefined')
+		b=bool;
+	else
+		b=true;
+	if(b){
+		if(this.iniciais.has(esta))
+			return;
+		this.iniciais[this.iniciais.length]=esta;
+	}
+	else{
+		if(!this.iniciais.has(esta))
+			return;
+		this.iniciais.remove(this.iniciais.pos(esta));
+	}
+};
+
+/**
+ * Método que devolve uma string com a descrição do autómato
+ * @return {String} descrição com as transições do autómato
+ */
+Automato.prototype.toString=function(){
+	var out="Alfabeto: "+this.alfabeto.toString()+"\n";
+	out+="Estados: "+this.estados.toString()+"\n";
+	out+="Iniciais: "+this.iniciais.toString()+"\n";
+	out+="Finais: "+this.finais.toString()+"\n";
+	out+="Transições: "+this.transicoes.toString()+"\n";
+	return out;
+};
+
+var noarvore=function(key,val){
+	this.esq=null;
+	this.dir=null;
+	this.key=key;
+	this.val=val;
+}
+
+
+
+var Tree=function(){
+	this.raiz=new noarvore(null,null);
+};
+
+/**
+ * Método que insere 
+ * @param {Número} key Chave numérica
+ * @param {Object} val Objecto que representa o valor que se encontra nos nós da árvore
+ */
+Tree.prototype.insertElement=function(key,val){
+	//caso a árvore esteja vazia insere imediatamente no lado esquerdo da árvore
+	var elaux=this.dir;
+	if(this.esq==null){
+		this.esq=new noarvore(key,val);
+	}
+	else{
+		//Enquanto não estivermos numa folha da árvore
+		while(elaux.dir!=null){
+			//Se a chave à direita for maior que a chave inserida então percorremos a árvore pela sua folha esquerda
+			if(elaux.key>key){
+				elaux=elaux.esq;
+			}
+			else{
+				elaux=elaux.dir;
+			}		
+		}
+	}
+}
+
+
+COOkie.getCookie=function(c_name)
+{
+if (document.cookie.length>0)
+  {
+  c_start=document.cookie.indexOf(c_name + "=");
+  if (c_start!=-1)
+    {
+    c_start=c_start + c_name.length+1;
+    c_end=document.cookie.indexOf(";",c_start);
+    if (c_end==-1) c_end=document.cookie.length;
+    return unescape(document.cookie.substring(c_start,c_end));
+    }
+  }
+return "";
+};
+
+/**
+ * Método que devolve uma string contendo as propriedades deste objecto
+ * @return {string} str String contendo informação sobre as propriedades do objecto
+ */
+Object.prototype.inspect=function(){
+	var str="";
+	var filho;
+	for(filho in this){
+		if(typeof(this[filho])=='function')
+			str+="Função: "+filho+"\n";
+		else
+			str+="Variável: "+filho+"-->"+this[filho]+"\n";
+	}
+	return str;
+};
+
+/**
+ * Método privado que devolve uma string com a representação JSON do objecto
+ * @param {Object} obj Objecto que se pretende exportar para JSON
+ * @private
+ */
+Object._toJSONString=function(obj){
+	var str="";
+	var e;
+	console.log(typeof(obj));
+	if(obj==null)
+		return "null";
+	if(typeof(obj)=='number'){
+			str+=obj;
+			return str;
+	}
+	else if(typeof(obj)=='string'){
+			str+="'"+obj+"'";
+			return str;
+	}
+	else if (typeof(obj) == 'object') {
+		if (typeof(obj.length) == "undefined") {
+			str += "{";
+			var k = 0;
+			for (e in obj) {
+				if (typeof(obj[e]) != "function") {
+					if (k != 0) {
+						str += ",";
+					}
+					str +='"'+e+'":'+ Object._toJSONString(obj[e]);
+					k++;
+				}
+			}
+			str += "}";
+		}
+		else {
+			str += "[";
+			for (var i = 0; i < obj.length; i++) {
+				if (typeof(obj[i]) != "function") {
+					if (i != 0) {
+						str += ",";
+					}
+					str += Object._toJSONString(obj[i]);
+				}
+			}
+			str += "]";
+		}
+	}
+	
+	return str;
+}
+
+/**
+ * Método que devolve uma string representando o objecto
+ * @return {String} str string contendo a representação JSON do objecto
+ */
+Object.prototype.toJSONString=function(){
+	return Object._toJSONString(this);
+}
+/**
+ * Método que transforma um objecto do tipo dicionário num array binário
+ * @return {Array} arr Array binário contendo os valores do objecto dicionário
+ */
+Object.prototype.toDicArray=function(){
+	var arr=[];
+	var i=0;
+	for(e in this){
+		arr[i]=[];
+		arr[i][0]=e;
+		arr[i][1]=this[e];
+		i++;
+	}
+	return arr;
+};
+
+/**
+ * Método que devolve uma string contendo o nome de todos os métodos existentes no objecto
+ * @return {string} strm String com a descrição dos métodos
+ */
+Object.prototype.getMetodos=function(){
+	var str="";
+	for(var filho in this){
+		if(typeof(this[filho])=='function')
+			str+="Função: "+filho+"\n";
+	}
+	return str;
+};
+
+
+/**
+ * Método que devolve uma string contendo o nome e valor de todas as propriedades existentes
+ * no objecto
+ * @return {string} strp String com a descrição dos valores do objecto
+ */
+Object.prototype.getPropriedades=function(){
+	var str="";
+	for(var filho in this){
+		if(typeof(this[filho])!='function')
+			str="Variavel: "+this[filho];
+	}
+	return str;
+};
+
+Object.min=function(strA,strB){
+	return strB.length>strA.length?strA:strB;
+};
+
+Object.max=function(strA,strB){
+	return strA.length>=strB.length?strA:strB;
+};
+
+/**
+ * Devolve um array com os caracteres que constituem a string
+ * @return {Array}
+ */
+String.prototype.alphabet=function(){
+	var out=[];
+	var ext={};
+	for(var i=0;i<this.length;i++){
+		if(!ext[this.charAt(i)]){
+			ext[this.charAt(i)]=true;
+			out[out.length]=this.charAt(i);
+		}
+	}
+	return out;
+};
+
+/**
+ * Método que devolve a intersecção entre duas strings
+ * @param {String} strA String A
+ * @param {String} strB String B
+ * @return {String} out String intersecção
+ */
+String.and=function(strA,strB){
+	var min=String.min(strA,strB);
+	var max=String.max(strA,strB);
+	var out="";
+	for(var i=0;i<min.length;i++){
+		if(min.charAt(i)==max.charAt(i))
+			out+=max.charAt(i);
+	}
+	return out;
+};
diff --git a/css.css b/css.css
new file mode 100644
index 0000000..0b91fba
--- /dev/null
+++ b/css.css
@@ -0,0 +1,57 @@
+@CHARSET "UTF-8";
+
+body{
+	background: white;
+	font-family: sans-serif;
+	font-style: normal;
+	font-size:x-small;
+	font: monospace;
+}
+
+#sudoku{
+	margin-left: 5%;
+}
+#interface{
+	clear: both;
+}
+br{
+	clear:both;
+}
+
+div.vspace{
+	min-height: 10px;
+	clear: both;
+}
+
+div.pagbreak{
+		page-break-after: always;
+}
+
+#sudo_table{
+	page-break-inside: avoid;
+}
+table.par{
+	background-color: #AAAAAA;
+	color: black;
+	vertical-align: middle;
+	text-align: center;
+}
+
+table{
+	float:left;
+	page-break-after:auto;
+}
+
+table.impar{
+	background-color:#BBBBBB;
+	color:black;
+	vertical-align: middle;
+	text-align: center;
+}
+
+td{
+	min-width: 15px;
+	height: 15px;
+	border: dashed;
+	border-width: thin;
+}
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..0ab1ad4
--- /dev/null
+++ b/index.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+		<title>Sudoku</title>
+		<script type="text/javascript" src="js.js"></script>
+	 	<link href="css.css" type="text/css" rel="stylesheet"> 
+		<script type="text/javascript" src="sudoku.js"></script> 
+</head>
+<body>
+	<div id="sudoku">
+	</div>
+	<div id="interface">
+		<label>Escolha o número de sudokus a gerar:</label>
+		<select id="num_sud" onchange="gera('num_sud')">
+		</select>
+		<input type="button" value="Imprimir" id="print" onclick="window.print()">
+		<label>Com Soluções?</label><input id="com_sol" type="checkbox" onclick="gera('num_sud')"></input>
+	</div>
+</body>
+<script>
+	var MAXIT=10000;
+	var PopulateComboBox=function(id){
+		var c=$(id);
+		var opt;
+		var html="";
+		for(var i=1;i<=MAXIT;i++){
+			html+="<option value=\""+i+"\">"+i+"</option>";
+		}
+		c.innerHTML=html;
+	}
+
+	var gera=function(id){
+		var nsud=$(id).get('$option')[$(id).selectedIndex].value;
+		var ch=$('com_sol');
+		var s=new Sudoku();
+		var html="";
+		for(var i=1;i<=nsud;i++){
+			while(!s.buildSudoku());
+			html+=s.getSudoku();
+			if(ch.checked){
+				html+=s.toHTML();
+				html+="<div class='vspace'></div>";
+			}
+			else{
+				if(i%2==0)
+					html+="<div class='vspace'></div>";
+			}
+			if(ch.checked){
+				if(i%3==0)
+					html+="<div class='pagbreak'></div>";
+			}
+			else{
+				if(i%6==0) html+="<div class='pagbreak'></div>";
+			}
+		}
+		d.innerHTML=html;
+	}
+	PopulateComboBox('num_sud');
+	var d=$('sudoku');
+</script>
+</html>
diff --git a/js.js b/js.js
new file mode 100644
index 0000000..740ac89
--- /dev/null
+++ b/js.js
@@ -0,0 +1,2702 @@
+/*************************************************
+ * BaLHau LIB
+ * Esta biblioteca foi desenvolvida por Vítor Hugo Fernandes, a.k.a BaLHau
+ * @author Balhau
+ */
+/**
+ * Método que devolve os elementos que contém uma determinada className
+ * @param cls {@link String} nome da class
+ * @return {@link Array} contendo os elementos de uma determinada class
+ */
+var getByClassName=function(cls){
+	var el=document.getElementsByTagName('*');
+	var out=[];
+	for(var i=0;i<el.length;i++){
+		if(el[i].className==cls){
+			out[out.length]=el[i];
+		}
+	}
+	return out;
+};
+
+
+/**
+ * Função que nos devolve o elemento a partir do seu identificador, ou então os elementos que verificam um determinado 
+ * tipo de className, ou ainda o conjunto de elementos pertencentes a um tipo de tag
+ * @param {String} idel ID do elemento
+ */
+var $=function(idel){
+	if(typeof(idel)=='undefined' || idel==null)
+		return null;
+	if(typeof(idel)=="string"){
+		if(idel.charAt(0)=='#'){
+			if(document.getElementsByClassName){
+				return HElement.get(document.getElementsByClassName(idel.substr(1,idel.length)));
+			}else
+			{
+				return HElement.get(getByClassName(idel.substr(1,idel.length)));
+			}
+		}
+		if(idel.charAt(0)=='$'){
+			return HElement.get(document.getElementsByTagName(idel.substr(1,idel.length)));
+		}
+	}
+	return HElement.get(idel);
+};
+
+var $$=function(tag,n){
+	if(BLauLib.isUndefined(n)){
+		if(tag.charAt(0)=='#'){
+			return document.createAttribute(tag);
+		}
+		else{
+			return HElement.get(document.createElement(tag));
+		}
+	}
+	var out=[];
+	for(var i=0;i<n;i++){
+		out[i]=$$(tag);
+	}
+	return out;
+}
+
+
+/**
+ * Objecto que contém os scripts da aplicação
+ * @classDescription Objecto que representa a principal objecto da biblioteca. Dentro deste objecto encontram-se um conjunto de 
+ * outros objectos com propósitos mais específicos. Este consiste, portanto, num contentor de bibliotecas. Poucos métodos
+ * são directamente implementados neste objecto e em versões futuras poderão mesmo ser reagrupados noutras estruturas
+ * @author Balhau
+ * @constructor Construtor da API
+ */
+var BLauLib=function(){
+	this.versao=0.1;
+	this.author="Ví­tor Fernandes, a.k.a Balhau";
+};
+
+/**
+ * Método que devolve uma string com as horas a partir do total de segundos
+ * @param {Number} totseg
+ */ 
+BLauLib.segToHour=function(totseg){
+	var vmin=Math.floor((totseg/60)%60);
+	var vhor=Math.floor((totseg/3600)%24);
+	var min=vmin>=10?vmin:"0"+vmin;
+	var hora=vhor>=10?vhor:"0"+vhor;
+	var seg=(totseg%60)>=10?totseg%60:"0"+totseg%60;
+	var rt="";
+	rt=(hora>0)?hora+":":"";
+	rt+=min+":"+seg;
+	return rt;
+};
+
+/**
+ * Método que devolve os valores representados numa string URL no formato GET
+ * @return {Object} Variaveis e seus respectivos valores
+ */
+String.prototype.getVarsFromUrl=function(){
+	var aux=this.split("?");
+	if(aux.length==0)
+		return {};
+	var vars=aux[1].split("&");
+	var out={};
+	var par="";
+	for(var i=0;i<vars.length;i++){
+		par=vars[i].split("=");
+		out[par[0]]=par[1];
+	}
+	return out;
+}
+
+/**
+ * Objecto com um conjunto de funções utilitárias para manipulação de cookies
+ * @classDescription Objecto com um conjunto de funções utilitárias para manipulação de cookies.
+ */
+BLauLib.COOKIES=function(){
+	var vars=document.cookie.split(";");
+	var aux;
+	var assArray={};
+	for(var i=0;i<vars.length;i++){
+		aux=vars[i].split('=');
+		assArray[aux[0].trim()]=aux[1];
+	}
+	return assArray;
+};
+
+/**
+ * Método que adiciona um novo cookie no browser
+ * @param {String} name Nome do cookie
+ * @param {String} value Valor do cookie
+ * @param {String} time Validade do cookie
+ * @param {String} path Domínio do cookie
+ */
+BLauLib.COOKIES.add=function(name,value,time,path){
+	var pth=null;
+	if(!path)
+		pth="/";
+	else
+		pth=path;
+	var dt=new Date();
+	dt.setSeconds(dt.getSeconds()+time);
+	document.cookie=name+'='+value+'; expires='+dt.toUTCString()+'; path='+pth;
+}
+
+/**
+ * Método que nos devolve o tempo restante de sessão, redireccinando no final  
+ * @param {String} divid Identificador do div que contem o tempo
+ * @param {Number} totseg Número representando o total de segundos da hora.
+ * @param {String} Link com o endereço da página no final da sessão
+ */
+BLauLib.getTime=function(divid,totseg,redirect){
+	if(totseg>0){
+		var dvel=$(divid);
+		dvel.innerHTML=BLauLib.segToHour(totseg);
+		totseg=totseg-1;
+		setTimeout("BLauLib.getTime('"+divid+"',"+totseg+",'"+redirect+"')",1000);
+	}
+	else{window.location=redirect;}
+};
+
+/**
+ * Libraria para invocação de páginas através do protocolo XMLHttpRequest
+ * @classDescription Classe que implementa um conjunto de funcionalidades para comunicação assíncrona com servidores
+ * 
+ */
+BLauLib.Ajax=function()
+{
+	this._init_();
+};
+
+/**
+ * Objecto que representa o estado da ligação
+ * @classDescription Este objecto representa o estado da ligação assíncrona efectuada
+ */
+BLauLib.Ajax.Status={};
+/**
+ * Ligação efectuada com sucesso
+ */
+BLauLib.Ajax.Status.OK=200;
+/**
+ * Página não encontrada
+ */
+BLauLib.Ajax.Status.NotFound=404;
+
+BLauLib.Ajax.prototype._init_ = function(){
+	this.xmlHttp = false;
+	this.text="";
+	this.html="";
+	this.onLoaded=null;
+	this.onLoading=null;
+	this.onError=null;
+	this.postvars=[];
+	this.onCompleted=null;
+	try {
+		// tentativa para criar o objecto ajax para versões não IE
+			this.xmlHttp = new XMLHttpRequest();
+		} 
+	catch (e) {
+		// para IE6 ou mais recente
+		var XmlHttpVersions = ['MSXML2.XMLHTTP.6.0', 'MSXML2.XMLHTTP.5.0', 'MSXML2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP'];
+		// tenta todas as versões
+		for (var i = 0; i < XmlHttpVersions.length && !xmlHttp; i++) {
+			try {
+				// tenta o objecto para as várias versões do IE
+				this.xmlHttp = new ActiveXObject(XmlHttpVersions[i]);
+			} 
+			//ignora os erros
+			catch (ex) {
+			}
+		}
+	}
+};
+/**
+ * Adiciona um novo par (variável,valor) para envio no pedido ajax
+ * @param {String} name Nome da variável
+ * @param {String} value Valor da variável
+ * @return {void}
+ */
+BLauLib.Ajax.prototype.addVar=function(name,value){
+	this.postvars[this.postvars.length]=[name,value];
+};
+
+/**
+ * Método que devolve o objecto resposta do servidor enviado em formato JSON
+ * @return {Object} Objecto
+ */
+BLauLib.Ajax.prototype.getJSON=function(){
+	return BLauLib.FromJSON(this.text);
+}
+/**
+ * Limpa as variáveis POST presentes no objecto
+ * @return {void}
+ */
+BLauLib.Ajax.prototype.clearVars=function(){
+	this.postvars=[];
+};
+
+BLauLib.mousePos=function(ev){
+	if(ev.pageX || ev.pageY){ 
+		return {x:ev.pageX, y:ev.pageY}; 
+	} 
+	return { 
+		x:ev.clientX + document.body.scrollLeft - document.body.clientLeft, 
+		y:ev.clientY + document.body.scrollTop  - document.body.clientTop 
+	}; 
+};
+
+/**
+ * Método que codifica o array de variáveis post para uma string com a sua representação 
+ * @return{String} String com a representação das variáveis
+ */
+BLauLib.Ajax.prototype.encPostVars=function(){
+	var str="";
+	for(var i=0;i<this.postvars.length;i++){
+		if(i!==0){
+			str+="&";
+		}
+		str+=this.postvars[i][0]+"="+this.postvars[i][1];
+	}
+	return str;
+	
+};
+
+/**
+ * Método que efectua uma chamada Assíncrona pelo protocolo POST
+ * @param {String} pag Endereço da página
+ */
+BLauLib.Ajax.prototype.callPost=function(pag){
+	this.open("POST", pag);
+	this.send(this.encPostVars());
+}
+
+/**
+ * Objecto para manipulação de chamadas assíncronas com recurso a iframes
+ */
+BLauLib.AIM={};
+
+/**
+ * Método que cria um frame para chamada assí­ncrona
+ * @param {Object} Object com as funções callback
+ */
+BLauLib.AIM.criaFrame=function(callbackobject){
+	var id=Math.floor(Math.random()*10000);
+	id="frm_"+id;
+	var dcont=$$('div');
+	dcont.innerHTML="<iframe style='display:none' src='about:blank' id='"+id+"' name='"+id+"' onload=BLauLib.AIM.onLoaded('"+id+"')></iframe>";
+	document.body.appendChild(dcont);
+	var frm=$(id);
+	if(callbackobject){
+		if(typeof(callbackobject.onComplete)=="function")
+			frm.onComplete=callbackobject.onComplete;
+	}
+	return id;
+}
+
+BLauLib.AIM.form=function(formE,name){
+	formE.setAttribute('target',name);
+}
+
+BLauLib.AIM.submit=function(formE,callbackobject){
+	BLauLib.AIM.form(formE, BLauLib.AIM.criaFrame(callbackobject));
+	if(callbackobject){
+		if(typeof(callbackobject.onStart)=="function")
+			return callbackobject.onStart();
+		return true;
+	}else{
+		return true;
+	}
+}
+
+BLauLib.AIM.onLoaded=function(id){
+	var el=$(id);
+	if(el.contentDocument){
+		var doc=el.contentDocument;
+	}
+	else if(el.contentWindow){
+		var doc=el.contentWindow.document;
+	}
+	else{
+		var doc=window.frames[id].document;
+	}
+	
+	if(doc.location.href=="about:blank"){
+		return;
+	}
+	if(typeof(el.onComplete)=='function'){
+		el.onComplete(doc.body.innerHTML);
+	}
+}
+/**
+ * Método que efectua uma ligação assíncrona ao servidor
+ * @param {String} metodo Tipo de ligação POST/GET
+ * @param {String} urlAja Endereço da ligação
+ */
+BLauLib.Ajax.prototype.open=function(metodo,urlAja)
+{
+	//Copia das estruturas devido à   não visibilidade do operador "this" dentro do método "onreadystatechange"
+	
+	var onLoading=this.onLoading;
+	var onLoaded=this.onLoaded;
+	var onError=this.onError;
+	var ajax=this.xmlHttp;
+	var estado=this.xmlHttp.readyState;
+	var pthis=this;
+	var ready=function()
+	{
+		if(ajax.readyState==4)
+		{
+			if(typeof(onLoaded)=="function"){
+				pthis.text=ajax.responseText;
+				pthis.html=ajax.responseXML;
+				onLoaded();
+			}
+		}
+		if(ajax.readyState==2){
+			if(typeof(onLoading)=="function"){
+				onLoading();
+			}
+		}
+		if(ajax.readyState==3){
+			if(typeof(onError)=="function"){
+				onError();
+			}
+		}
+	};
+	this.xmlHttp.onreadystatechange=ready;
+	this.xmlHttp.open(metodo,urlAja);
+	if(metodo=="POST"|| metodo=="post"){
+		this.xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded;charset=UTF-8");
+	}
+};
+/**
+ * Método que envia uma mensagem para o servidor
+ * @param {String} conteúdo para o servidor
+ */
+BLauLib.Ajax.prototype.send=function(conteudo)
+{
+	this.xmlHttp.send(conteudo);
+};
+
+/**
+ * Devolve o dia da semana para um determinado mes de um determinado ano
+ * @param mes Mes
+ * @param ano Ano
+ * @return Índice do dia da semana
+ */
+Date.getFirstDayMonth=function(mes,ano){
+	var d=new Date(ano,mes);
+	d.setDate(1);
+	return d.getDay();
+};
+
+/**
+ * Método que devolve o número de dias de um mês
+ * @param mes Mes que se pretende saber o numero de dias
+ * @param ano Ano que se pretende saber o numero de dias
+ * @return Dias 28-31 dias do mes
+ */
+Date.getNumDaysMonth=function(mes,ano){
+	return 32-new Date(ano,mes,32).getDate();
+}
+
+BLauLib.UI={};
+/**
+ * Painel que apresenta os dados no ecran sob a forma paginada
+ * @param {String} Id do elemento contentor
+ * @param {Array} Array com os cabeçalhos
+ * @param {Array} Array com os dados tabelados
+ * @param {Number} Number com o número de elementos por página
+ */
+BLauLib.UI.NPaged=function(iddiv,aheaders,adata,nppag,css){
+	this.headers=aheaders;
+	this.data=adata;
+	this.nppage=nppag;
+	this.divp=$(iddiv);
+	this.tblcon=null;
+	this.idpr=this.divp.id;
+	this.pagenumber=1;
+	if(typeof(css)=="undefined")
+		this.css="npage";
+	else
+		this.css=css;
+	this.build();
+};
+
+/**
+ * Objecto que representa um objecto calendário
+ */
+BLauLib.UI.DatePicker=function(id){
+	this.id=id;
+	this.dinput=$$('input');
+	this.dbox=BLauLib.UI.DatePicker.buildDataBox(dinput);
+	
+	this.dinput.id="data_"+this.id;
+	this.dbox.id="dataBox_"+this.id;
+};
+
+/**
+ * Método que efectua a construção do div de dados
+ */
+BLauLib.UI.DatePicker.buildDateBox=function(inputobj){
+	var i_obj=$(inputobj);
+	var divbox=$$('div');
+	
+};
+
+
+/**
+ * Método que efectua a criação da tabela contentora das datas
+ * @param {obj} Elemento associado ao calendário
+ */
+BLauLib.UI.DatePicker._createTableDate=function(obj,id){
+		var DS=7;
+		var id=id;
+		var tbody=$$('table');		//Criação do elemento table que servirá de contentor do calendário
+		var linhas=$$('tr',DS+1);		//Numero de linhas da tabela
+		var cells=$$('td',46);		//Numero de células 46, inclui dias do mes, semana, cabeçalho e rodapé
+		tbody.className="dpTB";
+		tbody.id="dpTB_"+id;
+		//Configuração do cabeçalho
+		var btleft=$$('input');
+		var btright=$$('input');
+		var title=$$('div');
+		title.id="dpHeader_"+id;
+		
+		btleft.type="button";
+		btright.type="button";
+		btright.value=">";
+		btleft.value="<";
+		
+		cells[1].colSpan=DS-2;
+		cells[1].className="dpTTD";
+		
+		cells[0].add(btleft);
+		cells[1].add(title);
+		cells[2].add(btleft);
+		linhas[0].add(cells[0],cells[1],cells[2]);
+		//Configuração dos dias da semana
+		var dsem=cells.select(3,2+DS);
+		var dsm=["Do","Se","Te","Qu","Qu","Se","Sa"];
+		for(var i=0;i<DS;i++){
+			dsem[i].id="dia_"+i;
+			dsem[i].innerHTML=dsm[i];
+		}
+		linhas[1].add(dsem);
+		var dias=cells.select(DS+3,DS+3+33);	//34=4*7+6 dias 
+		//Configuração dos dias do mes
+		for(var i=2;i<DS;i++){
+				linhas[i].add(dias.select(7*(i-2),7*(i-1)-1));
+		}
+		//Configuração dos botões de fundo
+		
+		tbody.add(linhas);
+		return tbody;
+};
+
+/**
+ * Devolve o número de páginas necessárias para a representação dos dados
+ */
+BLauLib.UI.NPaged.prototype.getNPages=function(){
+	return this.data.length.ICDiv(this.nppage); 
+};
+
+/**
+ * Método responsável por mudar o conteúdo de página  
+ * @param npage  Numero da página
+ * @return Nada
+ */
+BLauLib.UI.NPaged.prototype.displayPage=function(npage){
+	this.pagenumber=npage;
+	this.tblcon.innerHTML="";
+	var posmin=(npage-1)*this.nppage;
+	var posmax=Math.min((npage)*this.nppage-1,this.data.length);
+	var aux1=null;
+	var aux2=null;
+	//preenche headers
+	aux2=$$('tr');
+	aux2.className=this.css+"_hd";
+	for(var i=0;i<this.headers.length;i++){
+		aux1=$$('td');
+		aux1.className=this.css+"_td_";
+		if((j%2)==0)
+			aux1.className+="par";
+		else
+			aux1.className+="impar";
+		aux1.innerHTML=this.headers[i];
+		aux2.add(aux1);
+	}
+	this.tblcon.add(aux2);
+	//preenche corpo
+	for(var i=posmin;i<posmax;i++){//itera sobre as linhas da matriz de dados
+		aux1=$$('tr');
+		if((i%2)==0)//paridade da coluna
+			aux1.className=this.css+"_tr_par";
+		else
+			aux1.className=this.css+"_tr_impar";
+		for(var j=0;j<this.data[i].length;j++){//itera sobre as colunas da matriz de dados
+			aux2=$$('td');
+			aux2.innerHTML=this.data[i][j];
+			aux2.className=this.css+"_td_";
+			if((j%2)==0)
+				aux2.className+="par";
+			else
+				aux2.className+="impar";
+			aux1.add(aux2);
+		}
+		this.tblcon.add(aux1);
+	}
+	this.setFooter(npage-1);
+}
+
+/**
+ * Função que remove uma entrada no objecto NPaged
+ * @param n Índice da entrada
+ * @param callback Função de callback
+ * @return void
+ */
+BLauLib.UI.NPaged.prototype.removeEntry=function(n,callback,s){
+	var posmin=(this.pagenumber-1)*this.nppage;
+	var posmax=Math.min((this.pagenumber)*this.nppage-1,this.data.length);
+	if(n<0 || n>=this.data.length) //caso o valor de n esteja fora do intervalo de dados
+		return;
+	if(n>=posmin && n<posmax){//caso o valor n pertenca à página que se encontra seleccionada
+		var linhas=this.tblcon.get('$tr');
+		var linha=linhas[n-posmin+1];
+		var obj=this;
+		var call=function(){
+			if(typeof callback!="undefined" && callback!=null)
+				callback();
+			obj.displayPage(obj.pagenumber);
+		}
+		linha.del(s,call);
+		this.data=this.data.remove(n);
+	}
+}
+
+BLauLib.UI.NPaged.prototype.setFooter=function(n){
+	for(var i=0;i<this.dfoot.childNodes.length;i++){
+		if(i==n)
+			this.dfoot.childNodes[i].className=this.css+"_bf_on";
+		else
+			this.dfoot.childNodes[i].className=this.css+"_bf";
+	}
+}
+
+BLauLib.UI.NPaged.prototype.build=function(){
+	var np=this.getNPages();
+	this.divp.innerHTML="";//apaga o conteudo presente no contentor pai
+	this.tblcon=$$('table');//tabela com os dados
+	this.divtbc=$$('div');
+	this.divtbc.className=this.css+"_table";
+	this.tblcon.className=this.css+"_table";
+	this.dfoot=$$('div');//divisor com os números
+	var aux1;
+	var aux2;
+	var obj=this.displayPage;
+	this.divtbc.add(this.tblcon);
+	this.divp.add(this.divtbc);
+	var obj=this;
+	//preenche divisor
+	var cls=function(a){
+		var ev=a?a:window.event;
+		var el=ev.currentTarget;
+		var num=parseInt(el.id.split("_")[1])+1;
+		obj.displayPage(num);
+	}
+	if(np>1){
+		for(var i=0;i<np;i++){
+			 aux1=$$('div');
+			 aux1.innerHTML=i;
+			 aux1.id="p_"+i;
+			 aux1.className=this.css+"_bf";
+			 aux1.onclick=cls;
+			 this.dfoot.add(aux1);
+		}
+		this.divp.add(this.dfoot);
+	}
+	//mostra a primeira página
+	this.displayPage(this.pagenumber);
+};
+/**
+ * Este objecto implementa uma interface para efectuar procuras
+ */
+BLauLib.UI.ISearch=function(id,parent,callback,height,txsize){
+	this.bheight=300;
+	if(!BLauLib.isUndefined(height) && !BLauLib.isNull(height))
+		this.bheight=height;
+	this.contentor=$(parent);
+	this.callback=callback;
+	this.datadiv=$$('div');
+	this.datadiv.className="scrolldata";
+	this.idsearch="search_"+id;
+	
+	this.intext=$$('input');
+	this.intext.id=this.idsearch+"_input";
+	this.intext.type="text";
+	this.intext.size=(typeof txsize == "undefined")?60:txsize;
+	this.table=$$('table');
+	var obj=this;
+	this.intext.onkeyup=function(){
+		if(typeof obj.callback!="undefined" && obj.callback!=null)
+			obj.callback();
+	}
+	this.table.className="isearcht";
+	this.datadiv.style.maxHeight=this.bheight+"px;";
+	this.build();
+};
+
+BLauLib.UI.ISearch.prototype.setText=function(val){
+	this.intext.value=val;
+}
+
+BLauLib.UI.ISearch.prototype.getText=function(){
+	return this.intext.value;
+}
+
+BLauLib.UI.ISearch.prototype.clearData=function(){
+	this.datadiv.innerHTML="";
+}
+
+BLauLib.UI.ISearch.prototype.build=function(){
+	var inputline=$$('tr');
+	var inputcell=$$('td');
+	
+	
+	
+	var trdata=$$('tr');
+	var tddata=$$('td');
+	
+	tddata.add(this.datadiv);
+	trdata.add(tddata);
+	inputcell.id=this.intext.id+"_td";
+	inputcell.add(this.intext);
+	inputline.add(inputcell);
+	
+	this.table.add(inputline);
+	this.table.add(trdata);
+	this.table.className="isearcht";
+	this.contentor.add(this.table);
+};
+
+
+/**
+ * Método que adiciona os dados ao objecto
+ * @return
+ */
+BLauLib.UI.ISearch.prototype.displayData=function(dt){
+	this.clearData();
+	var pdata=null;
+	if(typeof dt=="undefined" || dt==null)
+		return;
+	for(var i=0;i<dt.length;i++){
+		pdata=$$('div');
+		pdata.className="data";
+		pdata.innerHTML=dt[i];
+		this.datadiv.add(pdata);
+	}
+};
+
+/**
+ * Extensoes as primitvas de JavaScript
+ * Criacao de um wrapper para o objecto Element, HElement
+ * o objectivo consiste em extender os objectos Element sem entrar em conflito
+ * com as extensoes de otras bibliotecas, tais como Prototype, JQuery, etc
+ * @author Vitor Fernandes (a.k.a balhau)
+ */
+
+/**
+ * Metodo que efectua o resize de um array, devolve como parametro de saida 
+ * o array redimensionado
+ * @author Vitor Fernandes (a.k.a: Balhau)
+ */
+var e$=function(divel){return document.getElementById(divel);};
+
+/**
+ * Classe para efectuar a concatenação de strings de uma forma eficiente, substitui a operação "+="
+ * @param {String} str String String inicial
+ * @author Balhau
+ */
+var StringBuilder=function(str){
+	this._arrstr=[];
+	this._comp=str.length;
+	for(var i=0;i<str.length;i++){
+		this._arrstr[i]=str.charAt(i);
+	}
+};
+/**
+ * Método para concatenação de strings
+ * @param {String} str String que se pretende concatenar com a já existente representada sob a forma
+ * de array
+ */
+StringBuilder.prototype.append=function(str){
+	for(var i=0;i<str.length;i++){
+		this._arrstr[this._arrstr.length]=str.charAt(i);
+	}
+};
+
+/**
+ * Método que devolve o objecto string representado
+ * @return {String} String resultante da concatenação
+ */
+StringBuilder.prototype.toString=function(){
+	return this._arrstr.join('');
+};
+
+
+/**
+ * Efectua um resize no array removendo os elementos "undefined"
+ * @return {Array} Array onde foram removidos os elementos com valor "undefined"
+ */
+Array.prototype.resize=function()
+{
+	var arr=[];
+	var i;
+	var k=0;
+	for(i=0;i<this.length;i++)
+	{
+		if(typeof(this[i])=="undefined"){
+			continue;
+		}
+		arr[k]=this[i];
+		k++;
+	}
+	return arr;
+};
+
+/**
+ * Remove os elementos a partir do valor de endereço do objecto
+ * @param {Object} obj Objecto a remover
+ * @return {Array} Array
+ */
+Array.prototype.removeByObject=function(obj){
+	var out=[];
+	for(var i=0;i<this.length;i++){
+		if(this[i]!==obj)
+			out[out.length]=this[i];
+	}
+	return out;
+}
+
+/**
+ * Método que remove os elementos "undefined" e null de um array
+ * @return {Array} Array resultante da remoção de elementos null e undefined
+ */
+Array.prototype.clean=function(){
+	var out=[]
+	for(var i=0;i<this.length;i++){
+		if(this[i]!=null && typeof this[i]!="undefined")
+			out[out.length]=this[i];
+	}
+	return out;
+};
+
+/**
+ * Efectua a remoção de caracteres vazios à esquerda da string
+ * @return {String} String sem espaços brancos à esquerda
+ */
+String.prototype.ltrim=function(){
+	var i=0;
+	var cmp=this.length;
+	while(this.charAt(i)==' ' && i<cmp){
+		i++;
+	}
+	return this.substring(i, this.length);
+}
+
+String.prototype.addEvent=function(event,value){
+	return "<a "+event+"=\""+value+"\">"+this+"</a>";
+};
+
+/**
+ * Efectua a remoção de caracteres vazios à direita da string
+ * @return {String} String sem espaços brancos à direita
+ */
+String.prototype.rtrim=function(){
+	var i=this.length-1;
+	while(i>=0 && this.charAt(i)==' '){
+		i--;
+	}
+	return this.substring(0,i+1);
+}
+
+/**
+ * Verifica se uma string é vazia
+ * @return {Boolean} Valor verdadeiro caso a string seja vazia, falso caso contrário
+ */
+String.prototype.empty=function(){
+	return (this.trim()=='');
+}
+
+String.prototype.trim=function(){
+	return this.ltrim().rtrim();
+}
+
+/**
+ * Método que devolve um array de elementos que devolvem valor true quando passados para a função callback
+ * @param {Function} callback Função callback que avalia o elemento
+ * @return {Array} Array com os elementos que retornam valor true na avaliação pela função callback
+ */
+Array.prototype.where=function(callback){
+	var out=[];
+	for(var i=0;i<this.length;i++){
+		if(callback(this[i])){
+			out[out.length]=this[i];
+		}
+	}
+	return out;
+};
+
+Array.prototype.select=function (ini,end){
+	if(typeof end=="undefined") 
+		end=this.length+1;
+	return this.slice(ini,end+1);
+}
+
+/**
+ * Método que aplica uma função a todos os elementos de um determinado array
+ * @param callback Função callback executada sobre os elementos
+ * @return true ou false dependendo se o argumento da função é uma função ou não.
+ */
+Array.prototype.map=function(callback){
+	if(!BLauLib.isFunction(callback))
+		return false;
+	var cmp=this.length;
+	for(var i=0;i<cmp;i++){
+		callback(this[i]);
+	}
+	return true;
+};
+
+Array.prototype.AMap=function(callback){
+	if(!BLauLib.isFunction(callback))
+		return this.clona();
+	var cmp=this.length;
+	var out=[];
+	for(var i=0;i<cmp;i++){
+		out[i]=callback(this[i]);
+	}
+	return out;
+};
+
+Array.prototype.getObjectBy=function(paramname,value){
+	var prop=null;
+	for(var i=0;i<this.length;i++){
+		prop=this[i];
+		if(prop[paramname]==value)
+			return prop;
+	}
+	return null;
+};
+
+//NodeList.prototype.where=function(callback){
+//	var out=[];
+//	for(var i=0;i<this.length;i++){
+//		if(callback(this[i])){
+//			out[out.length]=this[i];
+//		}
+//	}
+//	return out;
+//}
+
+/**
+ * Devolve uma string com a representação dos elementos contidos no Array
+ * @return {String} String com a representação dos elementos presentes no Array
+ */
+Array.prototype.toString = function()
+{
+	var i;
+	var str="[";
+	for(i=0;i<this.length;i++)
+	{
+		if(i===0){
+			str+=this[i];
+		}
+		else{
+			str+=","+this[i];
+		}
+	}
+	str+="]";
+	return str;
+};
+
+/**
+ * Método que efectua a remoção do último elemento do array
+ * @return {Object} Elemento presente no array 
+ */
+Array.prototype.pop=function()
+{
+	var obj=this[this.length-1];
+	this.remove(this.length-1);
+	return obj;
+};
+
+/**
+ * Devolve a posição que um determinado objecto ocupa no array
+ * @param {Object} valor Objecto do array
+ * @return {Number} Posição do elemento do array, -1 caso o elemento não pertença ao array
+ */
+Array.prototype.getIndex=function(valor){
+	for(var i=0;i<this.length;i++){
+		if(this[i]==valor){	return i;}
+	}
+	return -1;
+};
+
+/**
+ * Método que adiciona um elemento ao array
+ * @param {Object} Objecto, ou lista de objectos a adicionar
+ * @return {Array} devolve o próprio array para efeitos de chaining
+ */
+Array.prototype.add = function(){
+	var args=arguments;
+	var cmp = this.length;
+	for(var i=0;i<args.length;i++){
+		this[cmp] = args[i];
+		cmp++;
+	}
+	return this;
+};
+
+Array.prototype.clone=function(){
+	var _c=[];
+	for(var k=0;k<this.length;k++){
+		_c[k]=this[k];
+	}
+	return _c;
+}
+/**
+ * Método que remove um elemento do array 
+ * @param {Number} indice Posição do elemento a remover
+ * @return {Array} devolve o array já sem o elemento
+ */
+Array.prototype.remove=function(indice)
+{
+	var _a=this.clone();
+	if(_a.length<=indice || indice<0){return [];}
+	delete(_a[indice]);
+	return _a.resize();
+};
+
+Number.prototype.tipo=function()
+{
+	return "numero";
+};
+
+
+
+/**
+ * Devolve a divisão inteira entre dois números arredondada por defeito
+ * @return {Number} Valor da divisão
+ */
+Number.prototype.IFDiv=function(a){
+	if(a==0)
+		return NaN;
+	return Math.floor(this/a);
+}
+
+/**
+ * Devolve a divisão inteira entre dois números arredondada por excesso
+ * @return {Number} Valor da divisão
+ */
+Number.prototype.ICDiv=function(a){
+	if(a==0)
+		return NaN;
+	return Math.ceil(this/a);
+}
+
+/**
+ * Devolve o valor do valor multiplicado por uma determinada percentagem
+ * @param {Number} a Percentagem
+ * @return {Number} Valor multiplicado pela percentagem a 
+ */
+Number.prototype.percent=function (a)
+{
+	return (this*a)/100;
+}
+
+String.prototype.tipo=function()
+{
+	return "string";
+};
+/**
+ * Valida uma string a partir de uma expressão regular
+ * @return {Boolean} Verdadeiro caso a string verifique a condição dada pela expressão regular, falso caso contrário
+ */
+String.prototype.valida=function(exreg){
+	return this.match(exreg)===null?false:true;
+};
+
+/**
+ * Método que extende a classe String, adicionando a possiblidade de reverter a ordem dos caracteres
+ * @return {@link String} String com os caracteres em ordem reversa
+ */
+String.prototype.reverse=function(){
+	var stou="";
+	for(var i=this.length-1;i>=0;i--){
+		stou+=this.charAt(i);
+	}
+	return stou;
+};
+
+/**
+ * Método que transforma uma String num array com a sua codificação UNicode
+ * @param {String} car Caracter separador
+ * @return {String} Codificação Unicode separada através do caracter car
+ */
+String.prototype.toUnicodeArray=function(car){
+	var sb=new StringBuilder('');
+	for(var i=0;i<this.length;i++){
+		if(i===0){sb.append(String(this.charCodeAt(i)));}
+		else{sb.append(car+""+this.charCodeAt(i));}
+	}
+	return sb.toString();
+};
+
+Array.prototype.tipo=function()
+{
+	return "array";
+};
+
+/**
+ * Método que cria um array com valores aleatórios
+ * @param {int} dim Dimensão do array
+ * @param {int} low Valor mínimo
+ * @param {int} sup Valor máximo
+ * @param {bool} intarray Valor booleano indicando se o array é composto por valores inteiros ou valores decimais
+ * @return {int} Array aleatório com dim elementos compreendidos entre low e sup
+ */
+Array.random=function(dim,low,sup,intarray){
+	var arr=[];
+	if(typeof(low)=='undefined')
+		low=0;
+	if(typeof(sup)=='undefined')
+		sup=100;
+	if(typeof(intarray)=='undefined')
+		intarray=true;
+	for(var i=0;i<dim;i++){
+		if(intarray)
+			arr[i]=Math.floor(Math.random()*(sup-low+1)+low);
+		else
+			arr[i]=Math.random()*(sup-low)+low;
+	}
+	return arr;
+};
+
+/**
+ * Método que devolve um array bidimensional com valores aleatórios 
+ * @param {Number} col Número de colunas da matriz
+ * @param {Number} lin Número de linhas da matriz
+ * @param {Number} low Mínimo possível
+ * @param {Number} sup Máximo possivel
+ * @param {Boolean} intarray True para valores inteiros, false para valores decimais
+ */
+Array.mrandom=function(col,lin,low,sup,intarray){
+	var out=[]
+	for(var i=0;i<lin;i++)
+		out[i]=Array.random(col,low,sup,intarray);
+	return out;
+}
+
+
+var Elemento={};
+
+Elemento.setAttribute=function(elemento,nome,valor){
+    switch(nome){
+        case "class":
+            if(typeof(ActiveXObject)!="undefined"){elemento.setAttribute("className",valor);}
+            else{elemento.setAttribute("class",valor);}
+            break;
+		case "checked":
+			elemento.defaultChecked=valor;
+			break;
+        default:
+            elemento.setAttribute(nome,valor);
+        }
+};
+
+Elemento.getAttribute=function(elemento,nome){
+    switch(nome){
+        case "class":
+            if(typeof(ActiveXObject)!="undefined"){return elemento.getAttribute('className');}
+            else{return elemento.getAttribute('class');}
+            break;
+        default:
+                return elemento.getAttribute(nome);
+    }
+};
+Elemento.criaRadioBox=function(id,nome,checked){
+	if(checked=="undefined"){
+		checked=false;
+	}
+	var radioInput;
+    try {
+        var radioHtml = '<input type="radio" name="' + nome + '"';
+        if ( checked ) {
+            radioHtml += ' checked="checked"';
+        }
+        radioHtml += '/>';
+        radioInput = document.createElement(radioHtml);
+		radioInput.setAttribute('id',id);
+    } catch( err ) {
+        radioInput = document.createElement('input');
+        radioInput.setAttribute('type', 'radio');
+        radioInput.setAttribute('name', name);
+		radioInput.setAttribute('id',id);
+        if ( checked ) {
+            radioInput.setAttribute('checked', 'checked');
+        }
+    }
+return radioInput;
+};
+
+Elemento.createInput=function(tipo,nome,id)
+{
+	var el;
+	if(id===undefined){
+		id=nome;
+	}
+	switch(tipo){
+		case "radio":
+			el=Elemento.criaRadioBox(id,nome,false);
+			break;
+		default:
+			el=document.createElement('input');
+			el.setAttribute('name',nome);
+			el.setAttribute('id',id);
+			el.setAttribute('type',tipo);
+			break;
+	}
+	return el;
+};
+
+
+Elemento.FX={};
+/**
+ * Objecto responsavel por extender funcionalidades ao objecto Element
+ * @classDescription Em vez de se proceder a uma extensao natural do objecto Element, baseado
+ * na adicao de novos metodos ao objecto em questao, efectuou-se a criacao de um novo objecto
+ * chamado HElement que copia todos os metodos e propriedades existentes no objecto Element.
+ * A razao pela qual se decidiu em criar este wrapper, vem pelo facto de evitar conflitos com
+ * outras librarias de javascript, nomeadamente jquery e prototype. 
+ * Este elemento tem uma unica desvantagem. Tem um overhead superior no inicalizar do objecto
+ * devido ao ciclo que copia as funcionalidades prototipadas.
+ * @author Balhau
+ */
+var HElement = function () {
+	this.clones=0;
+	this.evnts={"onmouseover":[],"onmousedown":[],"onmouseup":[],"onmouseout":[]};
+	this.ontransition=false;
+	this.isdrag=false;
+};
+
+
+HElement.Event={};
+
+
+HElement.Event.ONMOUSEOVER="onmouseover";
+
+HElement.Event.ONMOUSEUP="onmouseup";
+
+HElement.Event.ONMOUSEDOWN="onmousedown";
+
+HElement.Event.ONMOUSEOUT="onmouseout";
+
+/**
+ * Objecto reservado para implementação de funções para animar objectos
+ */
+HElement.prototype.FX={};
+/**
+ * Método que especifica a transparência do objecto em HTML
+ * @param {Object} val percentagem compreendida entre 0-100
+ */
+HElement.prototype.setAlpha=function(val){
+	//caso do IE
+	if(typeof(this.style.filter)!='undefined'){
+		this.style.zoom=1;
+		this.style.filter="alpha(opacity="+val+")";
+	}
+	//caso firefox, etc
+	else{
+		if(val<=0){
+			this.style.visibility="hidden";
+			}
+		else{
+			this.style.visibility="visible";
+		}
+		val=val/100;
+		this.style.opacity=val;
+	}
+	this.alpha=val;
+}
+
+/**
+ * Método que devolve a posição de um determinado elemento
+ * @return {Object} Objecto.x, Objecto.y
+ */
+HElement.prototype.getPos=function(){
+	var cX=this.offsetLeft;
+	var cY=this.offsetTop; 
+	var pai=this;
+	if (pai.offsetParent) {
+		while (pai = pai.offsetParent) {
+			cX += pai.offsetLeft;
+			cY += pai.offsetTop;
+		}
+	}
+	return {x: cX,y:cY};
+}
+
+/**
+ * Método que atribui uma posição a um elemento
+ * @param {Number} x Valor de X
+ * @param {Number} y Valor de Y 
+ */
+HElement.prototype.setPos=function(x,y){
+	this.style.position="absolute";
+	this.style.top=y+"px";
+	this.style.left=x+"px";
+}
+
+HElement.prototype.pai=function(){
+	return HElement.get(this.parentNode);
+}
+
+/**
+ * Método que devolve a actual transparência aplicada ao objecto
+ * @return Number Percentagem de transparência
+ */
+HElement.prototype.getAlpha=function(){
+	var rg=new RegExp();
+	//Caso IE;
+	if (typeof(this.style.filter) != 'undefined') {
+		if(this.style.filter===""){
+			return 100;
+		}
+		var match=/opacity=(.*)\)/i.exec(this.style.filter);
+		return parseInt(match[1]*100);
+	}
+	//Caso não IE
+	if(this.style.opacity===""){
+		return 100;
+	}
+	return this.style.opacity*100;
+};
+
+/**
+ * Método que remove um elemento do DOM
+ * @return
+ */
+HElement.prototype.del=function(s,callback){
+	if(typeof s=="undefined" || s==null){
+		var pai=HElement.get(this.parentNode);
+		var a=this;
+		pai.remove(a);
+		return;
+	}
+	var a=this;
+	this.desvanece(s,function(){a.del();if(typeof callback!="undefined" && callback!=null)callback();});
+}
+
+/**
+ * Metodo que inicializa o mecanismo de drag sobre um objecto
+ * @param x {@link Number} Coordenada em x
+ * @param y {@link Number} Coordenada em y
+ * @param callback {@link Function} Funcao callback executada a cada instancia do movimento
+ * @return
+ */
+HElement.prototype.startDrag=function(x,y,callback){
+	var isto=this;
+	if(x && y){
+		isto.mouseX=x;
+		isto.mouseY=y;
+		
+	}else{
+		isto.mouseX=0;
+		isto.mouseY=0;
+	}
+	if (isNaN(parseInt(isto.style.pixelLeft))) { isto.style.pixelLeft = isto.getPos().x; }
+	if (isNaN(parseInt(isto.style.pixelTop))) { isto.style.pixelTop = isto.getPos().y; }
+	
+	document.onmousemove=function(e){
+		var x = parseInt(isto.style.pixelLeft);
+		var y = parseInt(isto.style.pixelTop);
+ 
+		e = e ? e : window.event;
+		isto.style.pixelLeft = x + (e.clientX - isto.mouseX);
+		isto.style.pixelTop = y + (e.clientY - isto.mouseY);
+		isto.mouseX = e.clientX;
+		isto.mouseY = e.clientY;
+		if(callback){callback(x, y);}
+	}
+};
+
+
+/**
+ * Método que adiciona valores quando estamos na presença de um objecto do tipo select.
+ * Este método foi concebido devido às diferenças existentes entre os vários browsers
+ * @param {Object} value Valor da opção
+ * @param {Object} capt Label associado ao item
+ */
+//Método para adicionar valores a elementos
+HElement.prototype.addOption=function(value,capt,id){
+	switch(this.nodeName){
+		case "SELECT":
+			var noElem=HElement.createElement('option');
+			var indice=0;
+			var lastElem=null;
+			if(typeof(capt)=="undefined"){
+				noElem.text="undefined";
+			}
+			else{
+				noElem.text=capt;
+			}
+			if(typeof(id)=="undefined"){
+				noElem.id="id_"+value;
+			}
+			noElem.value=value;
+			if(this.selectedIndex!=-1){
+				this.indice=this.selectedIndex;
+				lastElem = this.options[indice];
+			}
+			try {
+				this.add(noElem,lastElem); // standards compliant; doesn't work in IE
+    		}
+    		catch(ex) {
+      			this.add(noElem, this.selectedIndex); // IE only
+    		}
+		default: 
+	}
+};
+
+
+/**
+ * Método que aplica um efeito de desvanecimento a elementos de HTML
+ * @param {Number} seg Número de segundos ate atingir a transparencia mínima
+ * @see #getAlpha
+ * @see #setAlpha
+ * @see #aparece
+ */
+HElement.prototype.desvanece=function(seg,callback){
+	var alphaAct=this.getAlpha();
+	this.transicaoAlpha(alphaAct,0,seg,callback);
+};
+
+/**
+ * Devolve o comprimento do elemento
+ * @return {Number} Comprimento, em pixeis, do elemento
+ */
+HElement.prototype.getWidth=function(){
+	return this.style.width===""? 0 : this.style.width.split("px")[0];
+}
+
+/**
+ * Atribui um comprimento ao elemento
+ * @param {Number} vl Comprimento em pixeis
+ */
+HElement.prototype.setWidth=function(vl){
+	this.style.width=vl+"px";
+}
+
+/**
+ * Atribui uma altura ao elemento
+ * @param {Number} vl Altura em pixeis
+ */
+HElement.prototype.setHeight=function(vl){
+	this.style.height=vl+"px";
+}
+
+/**
+ * Devolve o comprimento do elemento
+ * @return {Number} Comprimento, em pixeis, do elemento
+ */
+HElement.prototype.getHeight=function(){
+	return this.style.height===""? 0 : this.style.height.split("px")[0];
+}
+
+/**
+ * Método que aplica um efeito de reaparecimento a elementos de HTML
+ * @param {Number} seg Número de segundos ate atingir a transparencia máxima
+ * @see #setAlpha
+ * @see #setAlpha
+ * @see #desvanece
+ */
+HElement.prototype.aparece=function(seg,callback){
+	var alphaAct=this.getAlpha();
+	this.transicaoAlpha(alphaAct,100,seg,callback);
+};
+
+Object.prototype.select=function(callback){
+	var out=[];
+	if(this.length!=undefined){
+		for(var i=0;i<this.length;i++){
+			if(callback(this[i])){
+				out[out.length]=this[i];
+			}
+		}
+	}
+	return out;
+}
+
+Object.prototype.isFunction=function(){
+	return (this.constructor==Function)?true:false;
+}
+
+Object.prototype.isNum=function(){
+	return (this.constructor==Number)?true:false;
+}
+
+Object.prototype.isString=function(){
+	return (this.constructor==String)?true:false;
+}
+
+/**
+ * Metodo que detecta a intersecao entre o objecto instanciado e um outro passado por parametro
+ * @param {String} l Identificador do Elemento para o qual se pretende efectuar a comparacao de cplosap
+ */
+HElement.prototype.hitTest=function(l){
+	var l=document.getElementById(l);
+	function getOffset(o){
+		for(var r = {l: o.offsetLeft, t: o.offsetTop, r: o.offsetWidth, b: o.offsetHeight};
+			o = o.offsetParent; r.l += o.offsetLeft, r.t += o.offsetTop);
+		r.r += r.l; r.b += r.t;
+		return r;
+	}
+	for(var b, s, r = [], a = getOffset(this), j = isNaN(l.length), i = (j ? l = [l] : l).length; i;
+		b = getOffset(l[--i]), (a.l == b.l || (a.l > b.l ? a.l <= b.r : b.l <= a.r))
+		&& (a.t == b.t || (a.t > b.t ? a.t <= b.b : b.t <= a.b)) && (r[r.length] = l[i]));
+	return j ? !!r.length : r;
+};
+
+
+
+/**
+ * Método que efectua a duplicação em profundidade de um determinado Elemento HTML. Quando invocado este método
+ * cria um elemento idêntico ao elemento instanciado assim como os Elementos filhos num processo recursivo.
+ * Os identificadores são diferentes de cópia para cópia para evitar colisões em posteriores invocações de objectos
+ * a partir de javascript partindo do seu ID;
+ * @param {Booleano} Variável boleana indicando o tipo de clonagem. Caso este parãmetro não seja inserido
+ * ou seja verdadeiro a cópia é feita em profundidade, caso o valor seja falso temos unicament a cópia do elemento
+ * sem efectuar profundidade.
+ * @return {HElement} Devolve um objecto do tipo HElement que consiste no presente objecto duplicado
+ */
+HElement.prototype.clone = function(prof){
+	if(typeof(this.clones)=='undefined' || this.clones==null)
+		this.clones=0;
+	if(typeof(prof)=='undefined'){
+		prof=true;
+	}
+	var cln = document.createElement(this.tagName);
+	for (i = 0; i < this.attributes.length; i++) {
+		if (this.attributes[i].name == "id") {
+			cln.setAttribute(this.attributes[i].name, this.attributes[i].nodeValue + "_clone_" + this.clones);
+		}
+		else {
+			//cln.attributes[i]=document.createAttribute(el.attributes[i].name);
+			cln.setAttribute(this.attributes[i].nodeName,this.attributes[i].nodeValue);
+			if(typeof(this.innerText)!='undefined')
+				cln.innerText=this.innerText;
+		}
+	}
+	if (prof) {
+		var filhos = this.childNodes;
+		for (i = 0; i < filhos.length; i++) {
+			//Elementos do tipo TEXTO
+			if (filhos[i].nodeType == 3) {
+				cln.appendChild(filhos[i]);
+			}
+			else {
+				elF = HElement.get(filhos[i]);
+				cln.appendChild(HElement.get(elF.clone(prof)));
+			}
+		}
+	}
+	else 
+		cln.innerHTML = this.innerHTML;
+	return cln;
+};
+
+/**
+ * Método que coloca um elemento no centro da janela
+ */
+HElement.prototype.putAtCenter=function(){
+	var wd=BLauLib.Window.width();
+	var he=BLauLib.Window.height();
+	var sx=BLauLib.Window.scrX();
+	var sy=BLauLib.Window.scrY();
+	var x=wd/2+sx-this.offsetWidth/2;
+	var y=he/2+sy-this.offsetHeight/2;
+	this.style.position="absolute";
+	this.style.left=isNaN(x)?(wd/2+"px"):(x+"px");
+	this.style.top=isNaN(y)?(he/2+"px"):(y+"px");
+}
+
+/**
+ * Método que aplica uma função de callback aos elementos em profundidade
+ * @param {Function} callback
+ */
+HElement.prototype.traverse=function(callback){
+	callback(this);
+	for(var i=0;i<this.childNodes.length;i++){
+		HElement.get(this.childNodes[i]).traverse(callback);
+	}
+}
+
+/**
+ * Método que efectua o resize de um objecto
+ * @param {Event} mev Evento de rato
+ * @param {Number} minx Comprimento minimo
+ * @param {Number} miny Altura mínima
+ * @deprecated Método não deve ser utilizado, efectuar o resize utilizando a especificação CSS3
+ */
+HElement.prototype.resize=function(mev,minx,miny){
+	mev?mev:window.event;
+	if(!minx)
+		minx=0;
+	if(!miny)
+		miny=0;
+	var pos=this.getPos();
+	var xdiff=mev.clientX-pos.x;
+	var ydiff=mev.clientY-pos.y;
+	if(xdiff>minx)
+		this.style.width=xdiff+"px";
+	if(ydiff>miny)
+		this.style.height=ydiff+"px";
+}
+
+/***
+ * Objecto que representa uma contentor janela
+ * @classDescription Este objecto representa um contentor janela. O propósito consiste em simular um ambiente desktop
+ * a partir de construção de um conjunto de elementos e alguns métodos associados
+ * @param {String} nel Nome do elemento
+ * @param {String} titulo Titulo da janela
+ * @param {String} bdcontent Conteudo do contentor
+ * @param {Number} dimx Dimensão em X
+ * @param {Number} dimy Dimensão em Y
+ */
+BLauLib.Window=function(nel,titulo,bdcontent,dimx,dimy){
+	var nel=nel;
+	this.dx=null;
+	this.drag=false;
+	this.dy=null;
+	if(dimx && dimy){
+		dx=Math.max(dimx,BLauLib.Window.MIN_WIDTH);
+		dy=Math.max(dimy,BLauLib.Window.MIN_HEIGHT);
+	}
+	else{
+		dx=300;
+		dy=100;
+	}
+	this.titulo=titulo;
+	if(!nel){
+		nel=BLauLib.Window.COUNT;
+		BLauLib.Window.COUNT++;
+	}
+	
+	//contentor
+	this.contentor=$$("div");
+	
+	//topbar
+	this.tbbar=$$("div");
+	imgclose=$$("img");
+	//tabelatop
+	var tbartable=$$("table");
+	tbartable.className="tbwindow";
+	//tbartable.setWidth(dx);
+	
+	//titulo
+	this.divT=$$("div");
+	this.divT.innerHTML=this.titulo;
+	this.divT.className="titleheader";
+	
+	//divImgClose
+	var divImgClose=$$("div");
+	divImgClose.className="imgclose";
+	
+	//corpo
+	this.bd=$$("div");
+	this.bd.className="wcontent";
+	
+	this.contentor.className="wmain";
+	this.contentor.id="wd_"+nel;
+	this.contentor.setWidth(dx);
+	var obj=this.contentor;
+	var tbb=this.tbbar;
+	//top bar
+	this.tbbar.className="wheader";
+	this.tbbar.id="tpbar_"+nel;
+	//this.tbbar.setHeight(BLauLib.Window.TBAR_HEIGHT);
+	
+	
+	imgclose.id="imgclose_"+nel;
+	imgclose.src=BLauLib.Window.IMGCLOSE;
+	var evimgclose=function(ev){
+		var el=HElement.get(obj);
+		var onimgclose=function(){
+			el.parentNode.removeChild(el);
+		}
+		el.desvanece(0.2,onimgclose);
+	}
+	
+	
+	this.bd.className="wcontent";
+	this.bd.id="bd_"+nel;
+	this.bd.style.minHeight=dy+"px";
+	this.bd.innerHTML=bdcontent;
+	
+	//adiciona os elementos ao top bar
+	this.tbbar.appendChild(this.divT);
+	divImgClose.appendChild(imgclose);
+	this.tbbar.appendChild(divImgClose);
+	
+	//eventos
+	var isto=this;
+	this.tbbar.onmousedown=function(e){
+		e=e?e:window.event;
+		isto.drag=true;
+		var elH=HElement.get(obj);
+		var hD=HElement.get(tbb);
+		var pnt=elH.startDrag(e.clientX,e.clientY,null);
+	}
+	
+	this.tbbar.onmouseup=function(){
+		document.onmousemove=null;
+		isto.drag=false;
+	}
+
+	imgclose.onmouseup=evimgclose;
+	this.contentor.appendChild(this.tbbar);
+	this.contentor.appendChild(this.bd);
+}
+
+/**
+ * Método que devolve o div contentor da janela
+ */
+BLauLib.Window.prototype.getContentor=function(){
+	return this.contentor;
+}
+
+/**
+ * Método que atribui uma determinada transparência à janela
+ * @param {Number} val Transparência, valor entre 0 e 100
+ */
+BLauLib.Window.prototype.setAlpha=function(val){
+	this.contentor.setAlpha(val);
+}
+
+/**
+ * Método que permite especificar o conteúdo do contentor da janela
+ * @param {String} val String contendo o HTML que irá ficar interno ao contentor da janela
+ */
+BLauLib.Window.prototype.setBodyContent=function(val){
+	this.bd.innerHTML=val;
+}
+
+/**
+ * Método que permite especificar o conteúdo da barra de título da janela
+ * @param {String} titulo HTML com o conteúdo a passar para a janela de título
+ */
+BLauLib.Window.prototype.setTitle=function(titulo){
+	this.divT.innerHTML=titulo;
+}
+/**
+ * Objecto Canvas que encapsular um conjunto de funcionalidades a operar sobre o objecto canvas
+ * @classDescription Neste objecto pretende-se encapsular um conjunto de funcionalidades que irão operar sob 
+ * a tag canvas. Este objecto consiste numa pequena API para automatizar algumas ferramentas e funcionalidades de
+ * computação visual que se pode efectuar recorrendo à especificação HTML5 
+ * @param {String} id identificador do objecto canvas
+ */
+BLauLib.Canvas=function(id){
+	this.canvas=$(id);
+	if(this.canvas && this.canvas.getContext){
+		this.c=this.canvas.getContext("2d");
+	}
+	else
+		throw "O browser não suporta o objecto canvas";
+}
+
+/**
+ * Método que especifica a função que será executada quando se efectua um varrimento da imagem pixel por pixel.
+ * A função enviada para o método será invocada para todos os valores de pixel. 
+ * @see #inverte
+ * @see #noiseImage
+ * @see #blackWhiteNoise
+ * @see #Threshold
+ * @param {Function} func Função callback
+ * @param {Object} args Argumentos adicionais para a função callback
+ */
+BLauLib.Canvas.prototype._ppixelCallback=function(func,args){
+	var imgd=this.c.getImageData(0,0,this.canvas.width,this.canvas.height);
+	var pixs=imgd.data;
+	var n=pixs.length;
+	var sm=0;
+	for(var i=0;i<n;i+=4){
+		var arr=func(pixs[i],pixs[i+1],pixs[i+2],pixs[i+3],args);
+		pixs[i]=arr[0];
+		pixs[i+1]=arr[1];
+		pixs[i+2]=arr[2];
+		pixs[i+3]=arr[3];
+	}
+	this.c.putImageData(imgd,0,0);
+}
+
+/**
+ * Método que efectua uma inversão de cor
+ */
+BLauLib.Canvas.prototype.inverte=function(){
+	this._ppixelCallback(function(r,g,b,a){
+		return [255-r,255-g,255-b,a];
+	},null);
+}
+
+/**
+ * Converte uma string para uma string de representação hexadecimal
+ * @return {String} String com a representação hexadecimal
+ */
+String.prototype.Hexify=function(){
+	var strout="";
+	for(var i=0;i<this.length;i++){
+		strout+="\\x"+this.charCodeAt(i).DecToHex();
+	}
+	return strout;
+}
+
+/**
+ * Método que transforma uma string de codigos hexadecimais na sua representação de caracteres
+ * @return {String} Devolve a string original
+ */
+String.prototype.DHexify=function(){
+	var arrCods=this.split("\\x");
+	var strout="";
+	for(var i=1;i<=this.length;i++){
+		strout+=String.fromCharCode(parseInt(arrCods[i],16));
+	}
+	return strout;
+}
+
+/**
+ * Converte um número Decimal para a sua representação Hexadecimal
+ * @return {Number} representação hexadecimal
+ */
+Number.prototype.DecToHex=function(){
+	return this.toString(16);
+}
+
+/**
+ * Converte um número Hexadecimal para a sua representação Decimal
+ * @return {Number} representação Decimal
+ */
+Number.prototype.HexToDec=function(){
+	return parseInt(this,16);
+}
+
+
+/**
+ * Preenche a imagem a ruido com cores
+ * @param {Number} alpha parametro de transparência 
+ */
+BLauLib.Canvas.prototype.noiseImage=function(alpha){
+	this._ppixelCallback(function(){
+		if(!arguments[4])			
+			return [Math.floor(Math.random()*255),Math.floor(Math.random()*255),Math.floor(Math.random()*255),Math.floor(Math.random()*100)];
+		return [Math.floor(Math.random()*255),Math.floor(Math.random()*255),Math.floor(Math.random()*255),arguments[4]];
+	},alpha);
+}
+
+/**
+ * Preenche a imagem a ruido a preto e branco
+ */
+BLauLib.Canvas.prototype.blackWhiteNoise=function(){
+	this._ppixelCallback(function(){
+		if(Math.random()>0.5)
+			return [255,255,255,100];
+		return [0,0,0,100]
+	},null)
+}
+
+
+/***
+ * Aplica threshold na imagem
+ * @param {Number} treshold Limite de threshold
+ */
+BLauLib.Canvas.prototype.Threshold=function(tresh){
+	this._ppixelCallback(function(px1,px2,px3,alpha,tr){
+		var arr=[];
+		sm=(px1+px2+px3)/3;
+		if(sm<tr) arr[0]=arr[1]=arr[2]=0;else arr[0]=arr[1]=arr[2]=255;
+		arr[3]=alpha;
+		return arr;
+	},tresh);
+}
+
+/**
+ * Método que carrega uma imagem para o objecto canvas efectuando um redimensionamento
+ * a partir do seu comprimento máximo
+ * @param {String} src Endereço da imagem
+ * @param {Number} xmax Comprimento máximo da imagem
+ */
+BLauLib.Canvas.prototype.loadScaledXImage=function(src,xmax){
+	var img=new Image();
+	var sfac=1;
+	img.src=src;
+	if (xmax && img.width > xmax) {
+		sfac = xmax / img.width;
+		img.width = img.width * sfac;
+		img.height = img.height * sfac;
+	}	
+	this.canvas.width = img.width;
+	this.canvas.height = img.height;
+	this.c.drawImage(img,0,0,img.width,img.height);
+	this.c.scale(sfac,sfac);
+}
+
+/**
+ * Método que carrega uma imagem para o objecto canvas efectuando um redimensionamento
+ * a partir da sua altura máxima
+ * @param {String} src Endereço da imagem
+ * @param {Number} xmax Altura máxima da imagem
+ */
+BLauLib.Canvas.prototype.loadScaledYImage=function(src,ymax){
+	var img=new Image();
+	var sfac=1;
+	img.src=src;
+	if (xmax && img.width > ymax) {
+		sfac = ymax / img.height;
+		img.width = img.width * sfac;
+		img.height = img.height * sfac;
+	}	
+	this.canvas.width = img.width;
+	this.canvas.height = img.height;
+	this.c.drawImage(img,0,0,img.width,img.height);
+	this.c.scale(sfac,sfac);
+}
+
+
+var HOSTNAME="";
+var DIR_IMAGENS="";
+BLauLib.Window.COUNT=0;
+BLauLib.Window.TBAR_HEIGHT=25;
+BLauLib.Window.BBAR_HEIGHT=25;
+BLauLib.Window.MIN_HEIGHT=100;
+BLauLib.Window.MIN_WIDTH=100;
+BLauLib.Window.IMGCLOSE=HOSTNAME+DIR_IMAGENS+"close16.png";
+BLauLib.Window.IMGRESIZE=HOSTNAME+DIR_IMAGENS+"resze.png";
+
+BLauLib.Window.width=function(){
+	return $('$html')[0].clientWidth;
+}
+
+BLauLib.Window.height=function(){
+	return $('$html')[0].clientHeight;
+}
+BLauLib.Window.scrX=function(){
+	return $('$html')[0].scrollLeft;
+}
+
+BLauLib.Window.scrY=function(){
+	return $('$html')[0].scrollTop;
+}
+
+BLauLib.MsgBox=function(tipoMsg,msg,titulo){
+	BLauLib.Window.apply(this, ["msg"+BLauLib.Window.COUNT,titulo,400,100]);
+	this.bd.innerHTML=msg;
+	return this.contentor;
+}
+/**
+ * Método que efectua a transicao entre dois niveis de transparencia
+ * @param {Number} alphaIni Percentagem de opacidade inicial
+ * @param {Number} alphaFin Percentagem de opacidade final
+ * @param {Number} seg Numero em segundos de duracao da transicao
+ * @see #desvanece
+ * @see #aparece
+ * @see #getAlpha
+ * @see #setAlpha
+ */
+HElement.prototype.transicaoAlpha=function(alphaIni,alphaFin,seg,callback){
+	if(!this.ontransition){
+		this.ontransition=true;
+		var cresc=true;
+		var transita=true;
+		if(alphaIni>alphaFin)
+			cresc=false;
+		var passo=(alphaFin-alphaIni)/(seg*24);
+		var alphaAct=alphaIni;
+		var obj=this;
+		var act=function(){
+			if ((cresc === true && alphaAct > alphaFin) || (cresc === false && alphaAct < alphaFin)) {
+				transita=false;
+				if(alphaAct>100){
+					obj.setAlpha(100)
+				}
+				if(alphaAct<0){
+					obj.setAlpha(0);
+				}
+				obj.ontransition=false;
+				clearInterval(i);
+				if(callback!=null){
+					callback();
+				}
+			}
+			else{
+				alphaAct+=passo;
+				obj.setAlpha(alphaAct);
+				
+			}
+		}
+		if(transita)
+			var i=setInterval(act,1000/30);
+	}
+};
+
+/**
+ * Método que remove um elemento filho a partir do seu identificador
+ * @param {String} id Identificador do elemento a remover
+ */
+HElement.prototype.removeChildById=function(id){
+	var cnt=this.childElementCount;
+	var filho=null;
+	for(var i=0;i<cnt;i++){
+		filho=this[i];
+		if(filho.id===id){
+			this.removeChild(filho);
+			cnt--;
+		}
+	}
+	return this;
+}
+
+/**
+ * Método que devolve o atributo do elemento a partir do seu identificador
+ * @param {String} attribute Identificador do atributo
+ * @return {Attribute} Elemento do tipo atributo
+ */
+HElement.prototype.getAttribute = function (attribute) {
+    if (attribute == "class") attribute = "className";
+    if (attribute == "for") attribute = "htmlFor";
+    return this[attribute];
+};
+
+/**
+ * Mecanismo responsavel por efectuar a troca de dois elementos
+ * Este metodo esta em fase de testes
+ * @param {HElement} el1 Elemento A
+ * @param {HElement} el2 Elemento B
+ */
+HElement.swap=function(el1,el2){
+	var p1=el1.parentNode;
+	var p2=el2.parentNode;
+	p1.insertBefore(el2.cloneNode(true),el1);
+	p2.insertBefore(el1.cloneNode(true),el2);
+	p1.removeChild(el1);
+	p2.removeChild(el2);
+};
+
+/**
+ * Metodo que especifica o valor para um dado atributo
+ * Metodo em desenvolvimento. Sempre que hajam algumas incompatibilidades de browser detectadas na
+ * especificacao de atributos deve-se alterar esta funcao para encapsular as diferencas
+ * @param {String} attribute Valor 
+ * @param {String} value Valor que se pretende associar ao atributo
+ */
+HElement.prototype.setAttribute = function (attribute, value) {
+    if (attribute == "class") attribute = "className";
+    if (attribute == "for") attribute = "htmlFor";
+    this[attribute] = value;
+};
+
+/**
+ * Método que especifica valores a atributos
+ * @param {String} atr Nome do atributo
+ * @param {Object} val Valor do atributo
+ */
+HElement.prototype.set=function(atr,val){
+	this.setAttribute(atr, val);
+}
+
+/**
+ * Método que adiciona um novo elemento filho ou um conjunto de elementos
+ * @param {HElement} arg Elemento filho
+ */
+HElement.prototype.add=function(){
+	if(arguments.length==1 && BLauLib.isArray(arguments[0])){
+		var arg=arguments[0];
+		for(var i=0;i<arg.length;i++){
+			this.appendChild(arg[i]);
+		}
+	}else{
+		for(var i=0;i<arguments.length;i++)
+			this.appendChild(arguments[i]);
+	}
+};
+
+/**
+ * Método que efectua a conversao de um determinado elemento para a estrutura HElement
+ * @param {Element} ele Objecto do tipo Element a converter
+ * @return {HElement} Objecto do tipo HElemento equivalente ao elemento fornecido.
+ */
+HElement.get=function(ele){
+	var el;
+	if(typeof(ele)=='undefined')
+			return null;
+	if(typeof(ele)=="NodeList"){
+		var cnt=ele.length;
+		var out=[];
+		for(var i=0;i<cnt;i++){
+			out[i]=HElement.get(ele[i]);
+		}
+		return out;
+	}
+	if(typeof(ele)=="number"){
+		return HElement.get(this.childNodes[ele]);
+	}
+	if(typeof(ele)=='string')
+		el=document.getElementById(ele);
+	else
+		el=ele;
+	var interf=new HElement();
+	for(metodo in interf){
+		//so assina se não estiver definido
+		if(el[metodo]==undefined)
+			try{el[metodo]=interf[metodo];}catch(e){}
+	}
+	return el;
+};
+
+/**
+ * Método que desabilita um elemento
+ * @param {Boolean} val True para desabilitar, false para habilitar
+ * @param {Boolean} recurs Recursivo ou não recursivo
+ */
+HElement.prototype.disable=function(val,recurs){
+	try{
+		this.disabled=val?true:false;
+	}
+	catch (e) {}
+	if(recurs){
+		var cmp=this.childNodes.length;
+		var hel=null;
+		for(var i=0;i<cmp;i++){
+			hel=HElement.get(this.childNodes[i]);
+			if(hel.disable)
+				hel.disable(val,recurs);
+		}
+	}
+};
+
+/**
+ * Devolve o número de filhos de um HElement 
+ * @return {Number} Número de filhos de um HElement
+ */
+HElement.prototype.length=function(){
+	return this.childNodes.length;
+}
+
+/**
+ * Devolve um elemento presente num HElement
+ * @param {Object} ele Objecto
+ * @return {HElement} 
+ */
+HElement.prototype.get=function(ele){
+	if(arguments.length==0)
+		return this.innerHTML;
+	if(typeof(ele)=='string')
+		idel=ele;
+	else
+		idel=ele.id;
+	if(idel.charAt(0)=='#'){
+		if(this.getElementsByClassName){
+			return HElement.get(document.getElementsByClassName(idel.substr(1,idel.length)));
+		}else
+		{
+			return HElement.get(getByClassName(idel.substr(1,idel.length)));
+		}
+	}
+	if(idel.charAt(0)=='$'){
+		return HElement.get(this.getElementsByTagName(idel.substr(1,idel.length)));
+	}
+	
+	return HElement.get(document.getElementById(idel));
+}
+
+/**
+ * Extende o metodo createElement para poder extender propriedades a elementos do IE
+ * @param {String} tagName Nome de tag do objecto a criar
+ */
+
+HElement.createElement = function(tagName) {
+    var element = document.createElement(tagName);
+    var interf = new HElement();
+    for (methodo in interf)
+        element[methodo] = interf[methodo];
+    return element;
+};
+/**
+ * Método que remove elementos filhos a partir da sua posição ou valor 
+ * @param {Number,Object} val
+ */
+HElement.prototype.clear=function(val){
+	if(arguments.length==0){
+		var ln=this.childNodes.length;
+		for(var i=0;i<ln;i++){
+			this.removeChild(this.childNodes[0]);
+		}
+	}
+	else{
+		if(typeof(val)=="number"){
+			this.removeChild(this.childNodes[val]);
+			return this;
+		}
+		this.removeChild(val);
+	}
+	return this;
+}
+
+HElement.prototype.remove=function(el){
+	this.removeChild(el);
+}
+
+HElement.dragElements=[];
+
+/**
+ * Nao esta definido porque entra em conflito com o jQuery
+
+Object.prototype.tipo=function()
+{
+	return "objecto";
+}
+*/
+Boolean.prototype.tipo=function()
+{return "booleano"};
+
+
+var utils=function()
+{
+	this.parseTipo=function(tipo,objName,val)
+	{
+		var s="";
+		if (tipo == "booleano") 
+			s += this.parseBool(val);
+		else if(tipo=="numero")
+			s+=this.parseNumber(val);
+		else if(tipo=="string")
+			s+=this.parseString(val);
+		else if(tipo=="array")
+			s+=this.parseArray(val,"");
+		else
+			s+=this.parseObj(val,"");
+		return s;
+	}
+	
+	this.parseObj=function(obj,str)
+	{
+		str+="{";
+		var k=0;
+		var o=null;
+		for(o in obj)
+		{
+			if(obj[o]==undefined){
+				if (k == 0)
+					str += '"'+o+'":undefined';
+				else {
+					str += ',"' + o+'":undefined';
+				}
+				k++;
+			}
+			else if(obj[o]==null){
+				if(k==0){
+					str += '"'+o+'":null';
+				}
+				else{
+					str +='"'+o+'":null';
+				}
+			}
+			else if (obj.propertyIsEnumerable(o) && typeof(obj[o].tipo)!="undefined") {
+				if (k == 0)
+					str += '"'+o+'":'+this.parseTipo(obj[o].tipo(), o, obj[o]);
+				else {
+					str += ',"' + o+'":' +this.parseTipo(obj[o].tipo(), o, obj[o]);
+				}
+				k++;
+			}
+			else{
+				if (obj.propertyIsEnumerable(o)) {
+					if (k == 0) 
+						str += '"'+o + '":' + this.parseObj(obj[o], "");
+					else 
+						str += ',"' + o + '":' + this.parseObj(obj[o], "");
+					k++;
+				}
+			}
+		}
+		return str+="}";
+	}
+	this.parseArray=function(obj,str)
+	{
+		str+="[";
+		var k=0;
+		var o=null;
+		for(o in obj)
+		{
+			if(obj[o]==undefined){
+				if (k == 0)
+					str += '"'+o+'":undefined';
+				else {
+					str += ',"' + '"'+o+'":undefined';
+				}
+				k++;
+			}
+			else if(obj[o]==null){
+				if(k==0){
+					str += '"'+o+'":null';
+				}
+				else{
+					str += '"'+o+'":null';
+				}
+			}
+			else if (obj.propertyIsEnumerable(o) && typeof(obj[o].tipo)!="undefined") {
+				if (k == 0)
+					str += this.parseTipo(obj[o].tipo(), o, obj[o]);
+				else {
+					str += "," +this.parseTipo(obj[o].tipo(), o, obj[o]);
+				}
+				k++;
+			}
+			else{
+				if (obj.propertyIsEnumerable(o)) {
+					if (k == 0) 
+						str += this.parseObj(obj[o], "");
+					else 
+						str += "," + this.parseObj(obj[o], "");
+					k++;
+				}
+			}
+		}
+		return str+="]";
+	}
+	this.parseNumber=function(objVal)
+	{
+		var s=objVal;
+		return s;
+	}
+	this.parseString=function(objVal)
+	{
+		var s='"'+objVal+'"';
+		return s;
+	}
+}
+
+utils.prototype.parseBool=function(val)
+{
+	if(val)
+		return "true";
+	return "false";
+}
+
+HElement.getFlashMovie=function(movieName) {
+	  var isIE = navigator.appName.indexOf("Microsoft") != -1;
+	  return (isIE) ? window[movieName] : document[movieName];
+};
+
+/**
+ * Objecto com um conjunto de funcionalidades para gestão de eventos
+ * @classDescription Para evitar que os eventos de rato e teclado associados ao elemento document sejam reassinados
+ * causando bugs nas aplicações foi criado este objecto para encapsular a funcionalidades referidas. Aqui encontramos um
+ * mecanismo de lista. Para cada evento existe uma lista com os métodos a invocar quando este é accionado. Desta forma 
+ * pode-se ter mais do que uma função associada aos vários eventos disponíveis
+ */
+BLauLib.Events={
+		loadwindow:[],
+		mousemovewindow:[],
+		mousedownwindow:[],
+		mousemovedocument:[],
+		mousedowndocument:[],
+		addEvent:function(funcao,evento){
+			var evList=this[evento];
+			evList[evList.length]=funcao;
+		},
+		clearEvents:function(evento){
+			if(this[evento])
+				this[evento]=[];
+		},
+		WindowLoad:"loadwindow",
+		WindowMouseMove:"mousemovewindow",
+		WindowMouseDown:"mousedownwindow",
+		DocumentMouseMove:"mousemovedocument",
+		DocumentMouseDown:"mousedowndocument"
+};
+
+
+/**
+ * Reeescreve o evento window.onload para que este suporte mais do que um evento
+ */
+window.onload=function(ev){
+	for(var i=0;i<BLauLib.Events.loadwindow.length;i++){
+		BLauLib.Events.loadwindow[i](ev);
+	}
+}
+
+/**
+ * Reescreve o evento onmousemove para que este suporte mais do que um evento
+ */
+window.onmousemove=function(ev){
+	for(var i=0;i<BLauLib.Events.mousemovewindow.length;i++){
+		BLauLib.Events.mousemovewindow[i](ev);
+	}
+}
+
+window.onmousedown=function(ev){
+	for(var i=0;i<BLauLib.Events.mousedownwindow.length;i++){
+		BLauLib.Events.mousedownwindow[i](ev);
+	}
+}
+
+document.onmousemove=function(ev){
+	for(var i=0;i<BLauLib.Events.mousemovedocument.length;i++){
+		BLauLib.Events.mousemovedocument[i](ev);
+	}
+}
+
+document.onmousedown=function(ev){
+	for(var i=0;i<BLauLib.Events.mousedowndocument.length;i++){
+		BLauLib.Events.mousedowndocument[i](ev);
+	}
+}
+
+
+/**
+ * Objecto que contem um conjunto de metodos de validação de expressões regulares
+ * para as principais entradas de formulário 
+ */
+BLauLib.Valida={
+		numerico:function(val){
+			return val.valida(/^[0-9]+$/);
+		},
+		maxchar:function(val,maxchar){
+			return val.valida("^[a-zA-Z0-9]{0,"+maxchar+"}$");
+		},
+		codPostalA:function(val){
+			return val.valida(/^[0-9]{4}$/);
+		},
+		codPostalB:function(val){
+			return val.valida(/^[0-9]{3}$/);
+		},
+		email:function(val){
+			return val.valida(/^[a-zA-Z0-9_.%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/);
+		},
+		webpage:function(val){
+			return val.valida(/^(http:\/\/)?[a-zA-Z0-9.]+\.[a-zA-Z]{2,4}(.)+$/);
+		},
+		telefone:function(val){
+			return val.valida(/^([0-9]{0,3})?[0-9]{9}$/);
+		}
+}
+/**
+ * Método que converte uma string json para o seu correspondente objecto
+ */
+BLauLib.FromJSON=function(a){
+	if(JSON.parse)
+		return JSON.parse(a);
+	return eval('('+a+')');
+}
+
+BLauLib.isFunction=function(obj){
+	return (typeof obj=="function");
+}
+
+BLauLib.isString=function(obj){
+	return (typeof obj=="string");
+}
+
+BLauLib.isUndefined=function(obj){
+	return (typeof obj=="undefined");
+}
+
+BLauLib.isNull=function(obj){
+	return (obj==null);
+}
+
+BLauLib.isArray=function(obj){
+	return BLauLib.isUndefined(obj)||BLauLib.isNull(obj)?false:(obj.constructor==Array);
+}
+
+/**
+ * Método que converte um objecto para a sua representação JSON
+ * @return {String} Representação JSON do objecto
+ */
+Object.prototype.toJSON =function() {
+	var obj=this;
+    var t = typeof (obj);  
+    if (t != "object" || obj === null) {  
+        // simple data type  
+        if (t == "string") obj = '"'+obj+'"';  
+        return String(obj);  
+    }  
+    else {  
+        // recurse array or object  
+        var n, v, json = [], arr = (obj && obj.constructor == Array);  
+        for (n in obj) {
+            v = obj[n]; t = typeof(v);
+            if(t!="function"){
+	            if (t == "string") v = '"'+v+'"';  
+	            else if (t == "object" && v !== null) v = v.toJSON();  
+	            json.push((arr ? "" : '"' + n + '":') + String(v));
+            }
+        }  
+        return (arr ? "[" : "{") + json + (arr ? "]" : "}");  
+    }  
+}; 
+/**
+ * Método que codifica uma string para uma outra que consiste na sequencia de numeros representando
+ * o caracter sob a numeração ascii separados por um caracter especial
+ * @param {Object} caracterseparador Caracter de separação
+ */
+String.prototype.toUnicodeArray=function(caracterseparador){
+	var i=0;
+	var stB=new StringBuilder("");
+	for(i=0;i<this.length;i++)
+	{
+		if(i==0)
+			stB.append(String(this.charCodeAt(i)));
+		else
+			stB.append(caracterseparador+this.charCodeAt(i));
+	}
+	return stB.toString();
+}
+/**
+ * Metodo que verifica se a string e um endereco de email
+ * @return {@link Boolean} Verdadeiro caso a string seja um endereco de email, falso caso contrario
+ */
+String.prototype.isEmail=function(){
+	var emailPattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;  
+	   return emailPattern.test(this);  
+};
+
+
+/**
+ * Método que transforma uma string codificada contendo os codigos unicode da string separados por um caracter separador.
+ * para o seu valor descodificado
+ * @param {String} caracter separador
+ * @return {String} String correspondente à  dada pela codificação unicode
+ */
+String.prototype.fromUnicodeArray=function(caracterseparador)
+{
+	var arrS=this.split(caracterseparador);
+	var strOut="";
+	for(i=0;i<arrS.length;i++)
+	{
+		strOut+=String.fromCharCode(arrS[i]);
+	}
+	return strOut;
+}
+
+/**
+ * Método que codifica uma string em formato UTF-8
+ * @return {String} String no formato UTF-8
+ */
+String.prototype.encodeUTF8=function(){
+	var string = this.replace(/\r\n/g,"\n");
+	var utftext = "";
+
+	for (var n = 0; n < string.length; n++) {
+
+		var c = string.charCodeAt(n);
+
+		if (c < 128) {
+			utftext += String.fromCharCode(c);
+		}
+		else if((c > 127) && (c < 2048)) {
+			utftext += String.fromCharCode((c >> 6) | 192);
+			utftext += String.fromCharCode((c & 63) | 128);
+		}
+		else {
+			utftext += String.fromCharCode((c >> 12) | 224);
+			utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+			utftext += String.fromCharCode((c & 63) | 128);
+		}
+	}
+	return utftext;
+}
+
+/**
+ * Método que descodifica uma string do formato UTF-8
+ * @return {String} String descodificada
+ */
+String.prototype.decodeUTF8=function(){
+	var string = "";
+	var i = 0;
+	var c = c1 = c2 = 0;
+
+	while ( i < this.length ) {
+
+		c = this.charCodeAt(i);
+
+		if (c < 128) {
+			string += String.fromCharCode(c);
+			i++;
+		}
+		else if((c > 191) && (c < 224)) {
+			c2 = this.charCodeAt(i+1);
+			string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+			i += 2;
+		}
+		else {
+			c2 = this.charCodeAt(i+1);
+			c3 = this.charCodeAt(i+2);
+			string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+			i += 3;
+		}
+	}
+	return string;
+}
+
+var Priberam=function(){
+	this.descricao="";
+	this.NDIV=32;
+	this.onLoaded=null;
+}
+
+var DragHandler = {
+		 
+		// private property.
+		_oElem : null,
+	 
+		// public method. Attach drag handler to an element.
+		attach : function(oElem,dgEl) {
+			oElem.onmousedown = DragHandler._dragBegin;
+			_dgEl=dgEl;
+			// callbacks
+			oElem.dragBegin = new Function();
+			oElem.drag = new Function();
+			oElem.dragEnd = new Function();
+			return oElem;
+		},
+	 
+	 
+		// private method. Begin drag process.
+		_dragBegin : function(e) {
+			var oElem = DragHandler._oElem = this;
+	 
+			if (isNaN(parseInt(oElem.style.left))) { oElem.style.left = '0px'; }
+			if (isNaN(parseInt(oElem.style.top))) { oElem.style.top = '0px'; }
+	 
+			var x = parseInt(oElem.style.left);
+			var y = parseInt(oElem.style.top);
+	 
+			e = e ? e : window.event;
+			oElem.mouseX = e.clientX;
+			oElem.mouseY = e.clientY;
+	 
+			oElem.dragBegin(oElem, x, y);
+	 
+			document.onmousemove = DragHandler._drag;
+			document.onmouseup = DragHandler._dragEnd;
+			return false;
+		},
+	 
+	 
+		// private method. Drag (move) element.
+		_drag : function(e) {
+			var oElem = DragHandler._oElem;
+	 
+			var x = parseInt(oElem.style.left);
+			var y = parseInt(oElem.style.top);
+	 
+			e = e ? e : window.event;
+			oElem.style.left = x + (e.clientX - oElem.mouseX) + 'px';
+			oElem.style.top = y + (e.clientY - oElem.mouseY) + 'px';
+	 
+			oElem.mouseX = e.clientX;
+			oElem.mouseY = e.clientY;
+	 
+			oElem.drag(oElem, x, y);
+	 
+			return false;
+		},
+	 
+	 
+		// private method. Stop drag process.
+		_dragEnd : function() {
+			var oElem = DragHandler._oElem;
+	 
+			var x = parseInt(oElem.style.left);
+			var y = parseInt(oElem.style.top);
+	 
+			oElem.dragEnd(oElem, x, y);
+	 
+			document.onmousemove = null;
+			document.onmouseup = null;
+			DragHandler._oElem = null;
+			alert("END");
+		}
+	}
+
+Priberam.prototype.get=function(pal){
+	var aj=new BLauLib.Ajax();
+	var dc;
+	var obj=this;
+	aj.addVar("url","http://www.priberam.pt/dlpo/default.aspx?pal="+encodeURI(pal));
+	aj.onLoaded=function(){
+		var eltmp=document.createElement('hidden');
+		eltmp.innerHTML=aj.text;
+		var dvs=eltmp.getElementsByTagName("div");
+		obj.descricao=dvs[obj.NDIV].innerHTML.decodeUTF8();
+		obj.onLoaded();
+	};
+	aj.open("POST","http://localhost/wbservices/wb_loadurl");
+	aj.send(aj.encPostVars());
+};
+
+/**
+ * Método que contém um conjunto de funcionalidades para o processamento de captchas
+ * @classDescription Este objecto pretende fornecer um conjunto de funcionalidades de manipulação de imagens gerados pelo
+ * sistema RECaptcha
+ * @param {String} pubkey Chave pública
+ * @param {String} privkey Chave privada
+ * @author Balhau
+ */
+var RECaptcha=function(pubkey,privkey){
+	this.publickey=pubkey;
+	this.privatekey=privkey;
+	this.challenge="";
+	this.challengeURL=RECaptcha.ServerName+"challenge?k="+this.publickey;
+}
+
+/**
+ * Método que utiliza um script de servidor para guardar imagens geradas pelo serviço RECaptcha
+ * @param {String} imgname Nome da imagem que pretendemos guardar
+ */
+RECaptcha.prototype.saveImage=function(imgname){
+	var aj=new BLauLib.Ajax();
+	var obj=this;
+	aj.onLoaded = function(){
+		var resp = aj.text;
+		resp=resp.split(";")[0];
+		resp=resp.split(",");
+		resp=resp[1].split(":");
+		resp=resp[1].replace(/'/gi,"");
+		obj.challenge=resp;
+		var naj=new BLauLib.Ajax();
+		var urlImg=RECaptcha.ServerName+"image?c="+resp.trim();
+		naj.addVar("url",urlImg);
+		naj.addVar("imgname",imgname);
+		naj.onLoaded=function(){
+		}
+		naj.callPost(RECaptcha.PHPCallbackFile);
+	}
+	aj.open("GET",RECaptcha.PHPRedirectFile+"?url="+this.challengeURL);
+	aj.send(null);
+}
+
+/**
+ * Nome do ficheiro que efectua o processamento das imagens geradas pelo mecanismo RECaptcha 
+ */
+RECaptcha.PHPCallbackFile="save.php";
+
+/**
+ * Nome do ficheiro que funciona como proxy para endereços externos.
+ */
+RECaptcha.PHPRedirectFile="redirect.php";
+
+/**
+ * Endereço do serviço RECaptcha 
+ */
+RECaptcha.ServerName="http://www.google.com/recaptcha/api/";
diff --git a/sudoku.js b/sudoku.js
new file mode 100644
index 0000000..807eabe
--- /dev/null
+++ b/sudoku.js
@@ -0,0 +1,258 @@
+/***
+ * Classe que implementa o Sudoku
+ * @author Balhau
+ * @classDescription O objecto Sudoku contém funções para geração de sudokus e respectivas soluções
+ * @requires Este ficheiro necessita do ficheiro js.js como requisito devido a funções utilitárias
+ */
+var Sudoku=function(){
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	this._mat=[];
+	this.clear();
+};
+
+Sudoku.getPosXY=function(pos){
+	var x=pos%9;
+	var y=Math.floor(pos/9);
+	return {"x":x,"y":y};
+};
+
+Sudoku.toPos=function(x,y){
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	if(x>=dx)
+		x=dx-1;
+	if(y>=dy)
+		y=dy-1;
+	return y*9+x;
+};
+/**
+ * Verifica se a coluna contem valores todos diferentes
+ * @param pos Posição no vector
+ * @param val Valor a colocar no vector
+ * @return Boolean
+ */
+Sudoku.prototype.checkColum=function(pos,val){
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	var p=Sudoku.getPosXY(pos);
+	for(var i=0;i<dy;i++){
+		if(this._mat[p.x+i*dy]==val)
+			return false;
+	}
+	return true;
+};
+
+/**
+ * Verifica se a linha contem valores todos diferentes
+ * @param pos Posição no vector
+ * @param val Valor a colocar no vector
+ * @return Boolean
+ */
+Sudoku.prototype.checkLine=function(pos,val){
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	var p=Sudoku.getPosXY(pos);
+	for(var i=0;i<dx;i++){
+		if(this._mat[p.y*dy+i]==val)
+			return false;
+	}
+	return true;
+};
+
+/**
+ * Método que verifica se o valor é válido para o bloco
+ * @param pos Indice do vector
+ * @param val Valor a atribuir
+ * @return
+ */
+Sudoku.prototype.checkBlock=function(pos,val){
+	var p=Sudoku.getPosXY(pos);
+	var pi,pj;//variaveis que identificam o bloco
+	if(p.x<3)pi=0;else if(p.x>=3 && p.x<6)pi=1;else	pi=2; 
+	if(p.y<3)pj=0;else if(p.y>=3 && p.y<6)pj=1;else	pj=2;
+	var ci=0;
+	var pii=pi*3;
+	var li=pj*9*3;
+	for(var i=0;i<9;i++){
+		if(i%3==0 && i!=0){
+			ci=0;
+			li+=9;
+		}
+		//var p=Sudoku.getPosXY(li+ci+pii);
+		//console.log("PosA: "+p.x+","+p.y);
+		if(this._mat[li+ci+pii]==val)
+			return false;
+		ci++;
+	}
+	return true;
+};
+
+/**
+ * Método que reinicia o vector com os valores do sudoku
+ * @return 
+ */
+Sudoku.prototype.clear=function(){
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	for(var i=0;i<dx*dy;i++){
+		this._mat[i]=-1;
+	}
+};
+
+/**
+ * Método que efectua uma limpeza nos n valores anteriores à posição pos
+ * @param pos Posição para a qual se pretende iniciar o reset de valores
+ * @param n Número de celulas que irão ser limpas
+ * @return 
+ */
+Sudoku.prototype.clearLastValues=function(pos,n){
+	var min=Math.max(0,n);
+	for(var i=min;i<=pos;i++){
+		this._mat[i]=-1;
+	}
+};
+
+Sudoku.DIMX=9;
+Sudoku.DIMY=9;
+Sudoku.BACK_TRACK_STEP=9;
+Sudoku.EASY=1;
+Sudoku.NORMAL=2;
+Sudoku.HARD=3;
+
+/**
+ * Método que gera uma instância do sudoku;
+ * @return
+ */
+Sudoku.prototype.buildSudoku=function(){
+	this.clear();
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	var num;
+	var maxit=100;
+	var maxitt=1000;
+	var it=0;
+	var step;
+	var itt=0;
+	for(var i=0;i<dx*dy;){
+		it++;
+		num=Math.floor(Math.random()*9)+1;
+		if(this.checkLine(i,num) && this.checkColum(i,num) && this.checkBlock(i, num)){//
+			it=0;
+			this._mat[i]=num;
+			i++;
+		}
+		if(it>maxit){
+			pos=Math.max(0,i-Sudoku.BACK_TRACK_STEP);
+			this.clearLastValues(i, pos);									//backtrack
+			i=pos;															//retorna atrás nas iteracções
+			it=0;																				//inicia o contador
+			itt++;
+		}
+		if(itt>maxitt){
+			i=maxitt;
+		}
+	}
+	if(i==maxitt)
+		return false;
+	return true;
+};
+
+/**
+ * Método que devolve os blocos do sudoku sob a forma de HTML
+ * @param x Ponto x do bloco
+ * @param y Ponto y do bloco  
+ * @return String com o código em HTML do bloco
+ */
+Sudoku.prototype.getHTMLBlock=function(x,y){
+	var pi,pj;//variaveis que identificam o bloco
+	if(x<3)pi=0;else if(x>=3 && x<6)pi=1;else pi=2; 
+	if(y<3)pj=0;else if(y>=3 && y<6)pj=1;else pj=2;
+	var ci=0;
+	var pii=pi*3;
+	var li=pj*9*3;
+	var ncl=((x+y)%2==0)?"par":"impar";
+	var str="<table class=\""+ncl+"\">\n\t<tr>";
+	for(var i=0;i<9;i++){
+		if(i%3==0 && i!=0){
+			ci=0;
+			li+=9;
+			str+="\n\t</tr>\n\t<tr>";
+		}
+		str+="\n\t\t<td>"+this._mat[li+ci+pii]+"</td>";
+		ci++;
+	}
+	str+="\n\t</tr>\n</table>";
+	return str;
+};
+
+/**
+ * Método que devolve uma instância do sudoku em função do seu nível de dificuldade
+ * @param level 
+ * @return
+ */
+Sudoku.prototype.getSudoku=function(level){
+	if(BLauLib.isUndefined(level))
+		level=Sudoku.EASY;
+	var comp=this._mat.length;
+	var pb=0.5-level*0.12;
+	var ninst=new Sudoku();
+	var mclone=this._mat.clone();
+	for(var i=0;i<comp;i++){
+		if(Math.random()<pb){
+			mclone[i]=this._mat[i];
+		}
+		else{
+			mclone[i]="_";
+		}
+	}
+	ninst._mat=mclone;
+	return ninst.toHTML();
+};
+
+/**
+ * Método que converte o sudoku para a sua representação sob a forma de código em HTML
+ * @return String em HTML
+ */
+Sudoku.prototype.toHTML=function(){
+	var dx=Sudoku.DIMX;
+	var dy=Sudoku.DIMY;
+	var str="<table class='sudo_table'>";
+	for(var i=0;i<3;i++){
+		str+="<tr>";
+		for(var j=0;j<3;j++){
+			str+="<td>"+this.getHTMLBlock(1+j*3,1+i*3)+"</td>";
+		}
+		str+="</tr>";
+	}
+	str+="</table>";
+	return str;
+};
+
+/**
+ * Método que devolve uma descrição do sudoku em forma de string
+ * @return String
+ */
+Sudoku.prototype.toString=function(){
+	var st="";
+	var cmp=this._mat.length;
+	var pl=1;
+	for(var i=0;i<cmp;i++){
+		if(i%3==0)
+			st+="|";
+		st+=this._mat[i]>0?this._mat[i]:" ";
+		if((i+1)%9==0){
+			pl++;
+			st+="|\n";
+		}
+		if(pl%4==0){
+			for(var j=0;j<9;j++){
+				st+="___";
+			}
+			st+="\n";
+			pl=1;
+		}
+	}
+	return st;
+};
+
diff --git a/test.html b/test.html
new file mode 100644
index 0000000..6a9c6be
--- /dev/null
+++ b/test.html
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+	<head>
+		<script src="corelib.js" language="JavaScript"></script>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+		<title>Js Test</title>
+	</head>
+	<body>
+	<canvas id="paint" width="600" height="480">
+	</canvas>
+	</body>
+</html>