From b715cbe6be1a70d11d69b5b9d801c58485188f7b Mon Sep 17 00:00:00 2001
From: snilard <mates.novotny@gmail.com>
Date: Mon, 27 May 2013 12:02:47 +0200
Subject: [PATCH] Adding simple Make project to test QuadDouble with tnl.

---
 examples/quad-test/.gitignore         |   3 +
 examples/quad-test/CMakeLists.txt     |   4 +
 examples/quad-test/Makefile           |  44 ++++
 examples/quad-test/Quad.cpp           | 285 +++++++++++++++++++++++++
 examples/quad-test/Quad.h             |  84 ++++++++
 examples/quad-test/Quadcpp.cpp        | 291 ++++++++++++++++++++++++++
 examples/quad-test/Quadcpp.h          |  53 +++++
 examples/quad-test/main.cpp           |  51 +++++
 examples/quad-test/quad-test.cfg.desc |  22 ++
 install                               |  47 +----
 10 files changed, 838 insertions(+), 46 deletions(-)
 create mode 100644 examples/quad-test/.gitignore
 create mode 100755 examples/quad-test/CMakeLists.txt
 create mode 100644 examples/quad-test/Makefile
 create mode 100644 examples/quad-test/Quad.cpp
 create mode 100644 examples/quad-test/Quad.h
 create mode 100644 examples/quad-test/Quadcpp.cpp
 create mode 100644 examples/quad-test/Quadcpp.h
 create mode 100644 examples/quad-test/main.cpp
 create mode 100644 examples/quad-test/quad-test.cfg.desc
 mode change 100755 => 120000 install

diff --git a/examples/quad-test/.gitignore b/examples/quad-test/.gitignore
new file mode 100644
index 0000000000..8542dc2c9e
--- /dev/null
+++ b/examples/quad-test/.gitignore
@@ -0,0 +1,3 @@
+*.o
+quad-test
+quad-test-conf.h
\ No newline at end of file
diff --git a/examples/quad-test/CMakeLists.txt b/examples/quad-test/CMakeLists.txt
new file mode 100755
index 0000000000..85e54342b7
--- /dev/null
+++ b/examples/quad-test/CMakeLists.txt
@@ -0,0 +1,4 @@
+INSTALL( FILES Makefile
+               main.cpp
+               program-name.cfg.desc
+         DESTINATION share/tnl-${tnlVersion}/examples/make-project )
\ No newline at end of file
diff --git a/examples/quad-test/Makefile b/examples/quad-test/Makefile
new file mode 100644
index 0000000000..0e7f888f1b
--- /dev/null
+++ b/examples/quad-test/Makefile
@@ -0,0 +1,44 @@
+TNL_VERSION=0.1
+TNL_INSTALL_DIR=${HOME}/local/lib
+TNL_INCLUDE_DIR=${HOME}/local/include/tnl-${TNL_VERSION}
+
+TARGET = quad-test
+CONFIG_FILE = $(TARGET).cfg.desc
+INSTALL_DIR = ${HOME}/local
+CXX = g++-4.7
+CUDA_CXX = nvcc
+CXX_FLAGS = -std=gnu++0x -I$(TNL_INCLUDE_DIR)
+LD_FLAGS = -L$(TNL_INSTALL_DIR) -ltnl-0.1 -lbz2
+
+SOURCES = main.cpp Quad.cpp Quadcpp.cpp
+HEADERS = Quad.h Quadcpp.h
+OBJECTS = main.o Quad.o Quadcpp.o
+DIST = $(SOURCES) Makefile
+
+all: $(TARGET)
+clean: 
+	rm -f $(OBJECTS)
+	rm -f $(TARGET)-conf.h	
+
+dist: $(DIST)
+	tar zcvf $(TARGET).tgz $(DIST) 
+
+install: $(TARGET)
+	cp $(TARGET) $(INSTALL_DIR)/bin
+	cp $(CONFIG_FILE) $(INSTALL_DIR)/share
+
+uninstall: $(TARGET)
+	rm -f $(INSTALL_DIR)/bin/$(TARGET) 
+	rm -f $(CONFIG_FILE) $(INSTALL_DIR)/share
+
+$(TARGET): $(OBJECTS)
+	$(CXX) -o $(TARGET) $(OBJECTS) $(LD_FLAGS)
+
+%.o: %.cpp $(TARGET)-conf.h $(HEADERS)
+	$(CXX) -c -o $@ $(CXX_FLAGS) $<
+
+$(TARGET)-conf.h:
+	echo "#define CONFIG_FILE \"${INSTALL_DIR}/share/${CONFIG_FILE}\" " > $(TARGET)-conf.h 
+
+format:
+	astyle --style=java --indent=force-tab --unpad-paren --close-templates $(SOURCES) $(HEADERS)
diff --git a/examples/quad-test/Quad.cpp b/examples/quad-test/Quad.cpp
new file mode 100644
index 0000000000..a687835f98
--- /dev/null
+++ b/examples/quad-test/Quad.cpp
@@ -0,0 +1,285 @@
+/*
+ *  Quad.c
+ *  Quad-C
+ *
+ *  Created by Matěj Novotný on 27.10.10.
+ *  Copyright 2010 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include <stdio.h>
+#include "Quad.h"
+
+#define ABS(n) ((n) > 0 ? (n): -(n))
+
+void threeThreeSum(double i0, double i1, double i2, double *o0, double *o1, double *o2) {
+	twoSum(i0, i1, &i1, &i0); // 1
+	twoSum(i1, i2, o0, &i1); // 2
+	twoSum(i0, i1, o1, o2); // 3
+}
+
+void threeTwoSum(double i0, double i1, double i2, double *o0, double *o1) {
+	twoSum(i0, i1, &i1, &i0); // 1
+	twoSum(i1, i2, o0, &i1); // 2
+	*o1 = i1 + i0; // 3
+}
+
+void fourTwoSum(double i0, double i1, double i2, double i3, double *o0, double *o1) {
+	twoSum(i0, i2, &i0, &i2); // 1
+	twoSum(i1, i3, &i1, &i3); // 2
+	i2 += i1; // 3
+	quickTwoSum(i0, i2, &i0, &i2); // 4
+	i3 += i2; // 5
+	quickTwoSum(i0, i3, o0, o1); // 6
+}
+
+void sixThreeSum(double i0, double i1, double i2, double i3, double i4, double i5, double *o0, double *o1,
+		double *o2) {
+	threeThreeSum(i0, i1, i2, &i2, &i0, &i1); // 1
+	threeThreeSum(i3, i4, i5, &i5, &i3, &i4); // 2
+	twoSum(i2, i5, o0, &i5); // 3
+	twoSum(i0, i3, &i0, &i3); // 4
+	twoSum(i0, i5, o1, &i5); // 5
+	*o2 = i1 + i4 + i3 + i5; // 6
+}
+
+void sixTwoSum(double i0, double i1, double i2, double i3, double i4, double i5, double *o0, double *o1) {
+	threeTwoSum(i0, i1, i2, &i1, &i0);	// 1
+	threeTwoSum(i3, i4, i5, &i4, &i3);	// 2
+	twoSum(i1, i4, o0, &i1);	// 3
+	*o1 = i0 + i3 + i1;	// 4
+}
+
+void nineTwoSum(double i0, double i1, double i2, double i3, double i4, double i5, double i6, double i7,
+		double i8, double *o0, double *o1) {
+	twoSum(i5, i6, &i5, &i6); // 1
+	twoSum(i4, i7, &i4, &i7); // 2
+	twoSum(i1, i2, &i1, &i2); // 3
+	twoSum(i0, i3, &i0, &i3); // 4
+	fourTwoSum(i4, i7, i5, i6, &i4, &i7); // 5
+	fourTwoSum(i0, i3, i1, i2, &i0, &i3); // 6
+	fourTwoSum(i0, i3, i4, i7, &i0, &i3); // 7
+	threeTwoSum(i3, i0, i8, o0, o1); // 8
+}
+
+void quickTwoSum(double a, double b, double *s, double *e) {
+	*s = a + b;
+	*e = b - (*s - a);
+}
+
+void twoSum(double a, double b, double *s, double *e) {
+	*s = a + b;
+	double v = *s - a;
+	*e = (a - (*s - v)) + (b - v);
+}
+
+void split(double a, double *a_hi, double *a_lo) {
+	double t = 134217729 * a;
+	*a_hi = t - (t - a);
+	*a_lo = a - *a_hi;
+}
+
+void twoProd(double a, double b, double *p, double *e) {
+	*p = a * b;
+	double a_hi, a_lo, b_hi, b_lo;
+	split(a, &a_hi, &a_lo);
+	split(b, &b_hi, &b_lo);
+	*e = ((a_hi * b_hi - *p) + a_hi * b_lo + a_lo * b_hi) + a_lo * b_lo;
+}
+
+void doubleAccumulate(double i0, double i1, double i2, double *o0, double *o1, double *o2) {
+	twoSum(i1, i2, o0, o2);
+	twoSum(i0, *o0, o0, o1);
+	if (*o1 == 0) {
+		*o1 = *o0;
+		*o0 = 0;
+	}
+	if (*o2 == 0) {
+		*o2 = *o1;
+		*o1 = *o0;
+		*o0 = 0;
+	}
+}
+
+void renormalize(double *a, double *b) {
+	double s;
+	double t[5];
+	int k = 0;
+	double e;
+	quickTwoSum(a[3], a[4], &s, t + 4);
+	quickTwoSum(a[2], s, &s, t + 3);
+	quickTwoSum(a[1], s, &s, t + 2);
+	quickTwoSum(a[0], s, t, t + 1);
+	s = *t;
+	int i;
+	zeroQuad(b);
+	for (i = 1; i < 5; i++) {
+		quickTwoSum(s, t[i], &s, &e);
+		if (s != 0) {
+			b[k] = s;
+			s = e;
+			k++;
+		}
+	}
+}
+
+void doublePlusQuad(double b, const double *a, double *s) {
+	double m[5];
+	double e = b;
+	int i;
+	for (i = 0; i < 4; i++) {
+		twoSum(e, a[i], m + i, &e);
+	}
+	m[4] = e;
+	renormalize(m, s);
+}
+
+void doubleTimesQuad(double b, const double *a, double *s) {
+	double m[7];
+	twoProd(b, a[0], m, m + 1); // 1
+	twoProd(b, a[1], m + 2, m + 3); // 2
+	twoSum(m[1], m[2], m + 1, m + 2); // 3
+	twoProd(b, a[2], m + 4, m + 5); // 4
+	threeThreeSum(m[4], m[3], m[2], m + 2, m + 3, m + 4); // 5
+	m[6] = b * a[3]; // 6
+	threeTwoSum(m[6], m[5], m[3], m + 3, m + 5); // 7
+	m[4] += m[5]; // 8
+	renormalize(m, s);
+}
+
+void quadDivDouble(const double *a, double b, double *s) {
+	//double b1[] = {b, 0, 0, 0};
+	//quadDiv(a, b1, s);
+	double m[13];
+	int i; // ten pĹŻjde odstranit
+	m[5] = a[0];
+	m[6] = a[1];
+	m[7] = a[2];
+	m[8] = a[3];
+	m[11] = 0;
+	m[12] = 0;
+	for (i = 0; i < 5; i++) {
+		m[i] = m[5] / b;
+		twoProd(-m[i], b, m + 9, m + 10);
+		//doubleTimesQuad(-m[i], b, m + 9);
+		quadAddAccurate(m + 5, m + 9, m + 5);
+	}
+	renormalize(m, s);
+}
+
+void quadAdd(const double *a, const double *b, double *s) {
+	double m[8];
+	twoSum(a[0], b[0], m, m + 1); // 1
+	twoSum(a[1], b[1], m + 2, m + 3); // 2
+	twoSum(m[2], m[1], m + 1, m + 2); // 3
+	twoSum(a[2], b[2], m + 4, m + 5); // 4
+	// blok 1							   5
+	threeThreeSum(m[4], m[3], m[2], m + 2, m + 3, m + 4);
+	twoSum(a[3], b[3], m + 6, m + 7); // 6
+	// blok 2							   7
+	threeTwoSum(m[6], m[5], m[3], m + 3, m + 5);
+	m[4] += m[5] + m[7];		// 8
+	renormalize(m, s);
+}
+
+void quadAddAccurate(const double *a, const double *b, double *s) {
+	double m[11];
+	int i = 0;
+	int j = 0;
+	int k = 0;
+	for (;i < 4 && j < 4;k++) {
+		if (ABS(a[i]) > ABS(b[j])) {
+			m[k] = a[i];
+			i++;
+		} else {
+			m[k] = b[j];
+			j++;
+		}
+	}
+	for (; i < 4; i++) {
+		m[k] = a[i];
+		k++;
+	}
+	for (; j < 4; j++) {
+		m[k] = b[j];
+		k++;
+	}
+	m[9] = 0.;
+	m[10] = 0.;
+	k = 0;
+	for (i = 0; k < 4 && i < 8; i++) {
+		doubleAccumulate(m[9], m[10], m[i], m + 8, m + 9, m + 10);
+		if (m[8] != 0) {
+			m[k] = m[8];
+			k++;
+		}
+	}
+	m[k] = m[9];
+	m[k + 1] = m[10];
+	for (i = k + 2; i < 5; i++) {
+		m[i] = 0;
+	}
+	renormalize(m, s);
+}
+
+void quadMul(const double *a, const double *b, double *s) {
+	double m[20];
+	twoProd(a[0], b[0], m, m + 1); // 1
+	twoProd(a[0], b[1], m + 2, m + 3); // 2
+	twoProd(a[1], b[0], m + 4, m + 5); // 3
+	threeThreeSum(m[1], m[2], m[4], m + 1, m + 2, m + 4); // 4
+	twoProd(a[0], b[2], m + 6, m + 7); // 5
+	twoProd(a[1], b[1], m + 8, m + 9); // 6
+	twoProd(a[2], b[0], m + 10, m + 11); // 7
+	sixThreeSum(m[2], m[3], m[5], m[6], m[8], m[10], m + 2, m + 3, m + 5); // 8
+	twoProd(a[0], b[3], m + 12, m + 13); // 9
+	twoProd(a[1], b[2], m + 14, m + 15); // 10
+	twoProd(a[2], b[1], m + 16, m + 17); // 11
+	twoProd(a[3], b[0], m + 18, m + 19); // 12
+	nineTwoSum(m[4], m[3], m[7], m[9], m[11], m[12], m[14], m[16], m[18], m + 3, m + 4); // 13
+	m[4] += m[5] + m[13] + m[15] + m[17] + m[19] + a[1] * b[3] + a[2] * b[2] + a[3] * b[1]; // 14
+	renormalize(m, s);
+}
+
+void quadMulQuick(const double *a, const double *b, double *s) {
+	double m[12];
+	twoProd(a[0], b[0], m, m + 1); // 1
+	twoProd(a[0], b[1], m + 2, m + 3); // 2
+	twoProd(a[1], b[0], m + 4, m + 5); // 3
+	threeThreeSum(m[1], m[2], m[4], m + 1, m + 2, m + 4); // 4
+	twoProd(a[0], b[2], m + 6, m + 7); // 5
+	twoProd(a[1], b[1], m + 8, m + 9); // 6
+	twoProd(a[2], b[0], m + 10, m + 11); // 7
+	sixTwoSum(m[2], m[3], m[5], m[6], m[8], m[10], m + 2, m + 3); // 8
+	m[3] += m[4] + m[7] + m[9] + m[11] + a[0] * b[3] + a[1] * b[2] + a[2] * b[1] + a[3] * b[0];  // 9
+	m[4] = 0;	// 10
+	renormalize(m, s);
+}
+
+void quadDiv(const double *a, const double *b, double *s) {
+	double m[13];
+	//double n[4];
+	//double k[4];
+	int i; // ten pĹŻjde odstranit
+	m[5] = a[0];
+	m[6] = a[1];
+	m[7] = a[2];
+	m[8] = a[3];
+	for (i = 0; i < 5; i++) {
+		m[i] = m[5] / b[0];
+		doubleTimesQuad(-m[i], b, m + 9);
+		quadAddAccurate(m + 5, m + 9, m + 5);
+	}
+	renormalize(m, s);
+}
+
+void zeroQuad(double *a) {
+	a[0] = 0;
+	a[1] = 0;
+	a[2] = 0;
+	a[3] = 0;
+}
+
+void printQuad(double *a) {
+	printf("%.15le + %.15le + %.15le + %.15le\n", a[0], a[1], a[2], a[3]);
+}
diff --git a/examples/quad-test/Quad.h b/examples/quad-test/Quad.h
new file mode 100644
index 0000000000..9539772533
--- /dev/null
+++ b/examples/quad-test/Quad.h
@@ -0,0 +1,84 @@
+/*
+ *  Quad.h
+ *  Quad-C
+ *
+ *  Created by Matěj Novotný on 27.10.10.
+ *  Copyright 2010 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+// Secte dva double
+// Parametry: a,b
+// Vysledek: s
+// Chyba: e
+// Predpokladame: abs(a) >= abs(b)
+void quickTwoSum(double a, double b, double *s, double *e);
+
+
+// Secte dva double
+// Parametry: a,b
+// Vysledek: s
+// Chyba: e
+void twoSum(double a, double b, double *s, double *e);
+
+// Rozdeli double na 2 casti po 26 bitech
+// Parametr: a
+// Rozdelene cislo: a_hi, a_lo
+void split(double a, double *a_hi, double *a_lo);
+
+// Vynasobi dva double
+// Parametry: a, b
+// Vysledek: p
+// Chyba: e
+void twoProd(double a, double b, double *p, double *e);
+
+// Normalizace cisla a
+// Vztup: pole peti prvku a
+// Vystup: pole ctyr prvku b
+void renormalize(double *a, double *b);
+
+// Secte double a quad-double
+// Parametry: double b, pole ctyr prvku a
+// Vysledek: pole ctyr prvku s
+void doublePlusQuad(double b, const double *a, double *s);
+
+// Vynasobi double a quad-double
+// Parametry: double b, pole ctyr prvku a
+// Vysledek: pole ctyr prvku s
+void doubleTimesQuad(double b, const double *a, double *s);
+
+void quadDivDouble(const double *a, double b, double *s);
+
+// Secte dva quad-double
+// Parametry: pole ctyr prvku a,b
+// Vysledek: pole ctyr prvku s
+void quadAdd(const double *a, const double *b, double *s);
+
+// Secte dva quad-double, pomalejsi algoritmus, ktery bude v krajnich priadech prejsi
+// Parametry: pole ctyr prvku a,b
+// Vysledek: pole ctyr prvku s
+void quadAddAccurate(const double *a, const double *b, double *s);
+
+// Vynasobi dva quad-double
+// Parametry: pole ctyr prvku a,b
+// Vysledek: pole ctyr prvku s
+void quadMul(const double *a, const double *b, double *s);
+
+// Vynasobi dva quad-double, rychle
+// Parametry: pole ctyr prvku a,b
+// Vysledek: pole ctyr prvku s
+void quadMulQuick(const double *a, const double *b, double *s);
+
+// Vydeli dva quad-double (a / b)
+// Parametry: pole ctyr prvku a,b
+// Vysledek: pole ctyr prvku s
+void quadDiv(const double *a, const double *b, double *s);
+
+// Vynuluje quad-double
+// Parametr: pole ctyr prvku a
+void zeroQuad(double *a);
+
+// Vytisne quad-double
+// Parametr: pole ctyr prvku a
+void printQuad(double *a);
+                                                          
\ No newline at end of file
diff --git a/examples/quad-test/Quadcpp.cpp b/examples/quad-test/Quadcpp.cpp
new file mode 100644
index 0000000000..b5dc91d01e
--- /dev/null
+++ b/examples/quad-test/Quadcpp.cpp
@@ -0,0 +1,291 @@
+#include "Quad.h"
+#include "Quadcpp.h"
+#include <math.h>
+
+
+QuadDouble::QuadDouble() {
+	zeroQuad(data);
+}
+
+QuadDouble::QuadDouble(double value) {
+	data[0] = value;
+	data[1] = 0;
+	data[2] = 0;
+	data[3] = 0;
+}
+
+QuadDouble::QuadDouble(const QuadDouble& other) {
+	data[0] = other[0];
+	data[1] = other[1];
+	data[2] = other[2];
+	data[3] = other[3];
+}
+
+/*QuadDouble::QuadDouble(double* other) {
+    double d[5];
+	d[0] = other[0];
+	d[1] = other[1];
+	d[2] = other[2];
+	d[3] = other[3];
+    d[4] = 0;
+    renormalize(d, data);	
+}*/
+
+double& QuadDouble::operator [](int idx) {
+	return data[idx];
+}
+
+const double& QuadDouble::operator [](int idx) const{
+	return data[idx];
+}
+
+QuadDouble& QuadDouble::operator =(const QuadDouble& rhs) {
+	data[0] = rhs[0];
+	data[1] = rhs[1];
+	data[2] = rhs[2];
+	data[3] = rhs[3];
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator +=(const QuadDouble& rhs) {
+	quadAddAccurate(data, rhs.data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator -=(const QuadDouble& rhs) {
+	quadAddAccurate(data, (-rhs).data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator *=(const QuadDouble& rhs) {
+	quadMul(data, rhs.data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator /=(const QuadDouble& rhs) {
+	quadDiv(data, rhs.data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator =(double rhs) {
+	data[0] = rhs;
+	data[1] = 0;
+	data[2] = 0;
+	data[3] = 0;
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator +=(double rhs) {
+	doublePlusQuad(rhs, data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator -=(double rhs) {
+	doublePlusQuad(-rhs, data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator *=(double rhs) {
+	doubleTimesQuad(rhs, data, data);
+	return *this;
+}
+
+QuadDouble& QuadDouble::operator /=(double rhs) {
+	quadDivDouble(data, rhs, data);
+	return *this;
+}
+
+QuadDouble QuadDouble::operator +(const QuadDouble& value) const{
+	QuadDouble qd(*this);
+	qd += value;
+	return qd;
+}
+
+QuadDouble QuadDouble::operator -(const QuadDouble& value) const{
+	QuadDouble qd(*this);
+	qd -= value;
+	return qd;
+}
+
+QuadDouble QuadDouble::operator *(const QuadDouble& value) const{
+	QuadDouble qd(*this);
+	qd *= value;
+	return qd;
+}
+
+QuadDouble QuadDouble::operator /(const QuadDouble& value) const{
+	QuadDouble qd(*this);
+	qd /= value;
+	return qd;
+}
+
+
+QuadDouble QuadDouble::operator +(const double& value) const {
+	QuadDouble qd(*this);
+	qd += value;
+	return qd;
+}
+
+QuadDouble QuadDouble::operator -(const double& value) const {
+	QuadDouble qd(*this);
+	qd -= value;
+	return qd;
+}
+
+QuadDouble QuadDouble::operator *(const double& value) const {
+	QuadDouble qd(*this);
+	qd *= value;
+	return qd;
+}
+
+QuadDouble QuadDouble::operator /(const double& value) const {
+	QuadDouble qd(*this);
+	qd /= value;
+	return qd;
+}
+
+bool QuadDouble::operator ==(const QuadDouble& rhs) const {
+	if (data[0] == rhs[0] && data[1] == rhs[1] && data[2] == rhs[2] && data[3] == rhs[3]) {
+		return true;
+	}
+	return false;
+}
+
+/*bool QuadDouble::operator ==(const QuadDouble& rhs) {
+	if (data[0] == rhs[0] && data[1] == rhs[1] && data[2] == rhs[2] && data[3] == rhs[3]) {
+		return true;
+	}
+	return false;
+}*/
+
+bool QuadDouble::operator !=(const QuadDouble& rhs) const {
+	return !(*this == rhs);
+}
+
+
+bool QuadDouble::operator <(const QuadDouble& rhs) const {
+	QuadDouble qd(*this);
+	qd -= rhs;
+	if (qd[0] < 0.) {
+		return true;
+	}
+	return false;
+}
+
+bool QuadDouble::operator >(const QuadDouble& rhs) const {
+	QuadDouble qd(*this);
+	qd -= rhs;
+	if (qd[0] > 0.) {
+		return true;
+	}
+	return false;
+}
+ 
+bool QuadDouble::operator >=(const QuadDouble& rhs) const {
+	QuadDouble qd(*this);
+	qd -= rhs;
+	if (qd[0] >= 0.) {
+		return true;
+	}
+	return false;
+}
+
+bool QuadDouble::operator <=(const QuadDouble& rhs) const  {
+	QuadDouble qd(*this);
+	qd -= rhs;
+	if (qd[0] <= 0.) {
+		return true;
+	}
+	return false;
+}
+
+QuadDouble QuadDouble::operator +() {
+	QuadDouble qd(*this);
+	return qd;
+}
+
+QuadDouble QuadDouble::operator -() {
+	QuadDouble qd(*this);
+	qd[0] = -qd[0];
+	qd[1] = -qd[1];
+	qd[2] = -qd[2];
+	qd[3] = -qd[3];
+	return qd;
+}
+
+QuadDouble QuadDouble::operator +() const {
+	QuadDouble qd(*this);
+	return qd;
+}
+
+QuadDouble QuadDouble::operator -() const {
+	QuadDouble qd(*this);
+	qd[0] = -qd[0];
+	qd[1] = -qd[1];
+	qd[2] = -qd[2];
+	qd[3] = -qd[3];
+	return qd;
+}
+
+QuadDouble::operator double() const{
+	return data[0];
+}
+
+QuadDouble operator+(double v1, const QuadDouble& v2) {
+    QuadDouble qd(v1);
+    qd += v2;
+    return qd;
+}
+
+QuadDouble operator-(double v1, const QuadDouble& v2) {
+    QuadDouble qd(v1);
+    qd -= v2;
+    return qd;
+}
+
+QuadDouble operator*(double v1, const QuadDouble& v2) {
+    QuadDouble qd(v1);
+    qd *= v2;
+    return qd;
+}
+
+QuadDouble operator/(double v1, const QuadDouble& v2) {
+    QuadDouble qd(v1);
+    qd /= v2;
+    return qd;
+}
+
+QuadDouble abs(const QuadDouble& value) {
+	QuadDouble qd(value);
+	if (value[0] < 0) {
+		qd = -qd;
+	}
+	return qd;
+}
+
+QuadDouble sqrt(const QuadDouble& value) {
+	QuadDouble qd(value);
+	QuadDouble x(1/sqrt((double)qd));
+	QuadDouble step;
+	//TODO zjednodušit dělení 2
+	step = x * (1. - qd * x * x);
+	step[0] /= 2;
+	step[1] /= 2;
+	step[2] /= 2;
+	step[3] /= 2;
+	x += step;
+	step = x * (1. - qd * x * x);
+	step[0] /= 2;
+	step[1] /= 2;
+	step[2] /= 2;
+	step[3] /= 2;
+	x += step;
+	step = x * (1. - qd * x * x);
+	step[0] /= 2;
+	step[1] /= 2;
+	step[2] /= 2;
+	step[3] /= 2;
+	x += step;
+	qd *= x;
+	return qd;
+}
\ No newline at end of file
diff --git a/examples/quad-test/Quadcpp.h b/examples/quad-test/Quadcpp.h
new file mode 100644
index 0000000000..b469816788
--- /dev/null
+++ b/examples/quad-test/Quadcpp.h
@@ -0,0 +1,53 @@
+class QuadDouble {
+private:
+public:
+	double data[4];
+	QuadDouble();
+	explicit QuadDouble(double);
+	QuadDouble(const QuadDouble&);
+	//QuadDouble(double*);
+	double& operator[](int);
+	const double& operator[](int) const;
+	QuadDouble& operator =(const QuadDouble&);
+	QuadDouble& operator +=(const QuadDouble&);
+	QuadDouble& operator -=(const QuadDouble&);
+	QuadDouble& operator *=(const QuadDouble&);
+	QuadDouble& operator /=(const QuadDouble&);
+	QuadDouble& operator =(double);
+	QuadDouble& operator +=(double);
+	QuadDouble& operator -=(double);
+	QuadDouble& operator *=(double);
+	QuadDouble& operator /=(double);
+	QuadDouble operator +(const QuadDouble&) const;
+	QuadDouble operator -(const QuadDouble&) const;
+	QuadDouble operator *(const QuadDouble&) const;
+	QuadDouble operator /(const QuadDouble&) const;
+	QuadDouble operator +(const double&) const;
+	QuadDouble operator -(const double&) const;
+	QuadDouble operator *(const double&) const;
+	QuadDouble operator /(const double&) const;
+	bool operator ==(const QuadDouble&) const;
+	bool operator !=(const QuadDouble&) const;
+	bool operator <(const QuadDouble&) const;
+	bool operator >(const QuadDouble&) const;
+	bool operator >=(const QuadDouble&) const;
+	bool operator <=(const QuadDouble&) const;
+	QuadDouble operator +();
+	QuadDouble operator -();
+	QuadDouble operator +() const;
+	QuadDouble operator -() const;
+	operator double() const;	
+};
+
+QuadDouble operator +(const double&, const QuadDouble&);
+QuadDouble operator -(const double&, const QuadDouble&);
+QuadDouble operator *(const double&, const QuadDouble&);
+QuadDouble operator /(const double&, const QuadDouble&);
+/*double& operator =(const QuadDouble&);
+double& operator +=(const QuadDouble&);
+double& operator -=(const QuadDouble&);
+double& operator *=(const QuadDouble&);
+double& operator /=(const QuadDouble&);*/
+
+QuadDouble abs(const QuadDouble&);
+QuadDouble sqrt(const QuadDouble&);
\ No newline at end of file
diff --git a/examples/quad-test/main.cpp b/examples/quad-test/main.cpp
new file mode 100644
index 0000000000..b4c8bc9955
--- /dev/null
+++ b/examples/quad-test/main.cpp
@@ -0,0 +1,51 @@
+/***************************************************************************
+								  main.cpp  -  description
+									  -------------------
+	 begin					 : Jan 12, 2013
+	 copyright				: (C) 2013 by Tomas Oberhuber
+	 email					 : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/***************************************************************************
+ *																			*
+ *	This program is free software; you can redistribute it and/or modify	*
+ *	it under the terms of the GNU General Public License as published by	*
+ *	the Free Software Foundation; either version 2 of the License, or		*
+ *	(at your option) any later version.										*
+ *																			*
+ ***************************************************************************/
+
+#include "quad-test-conf.h"
+#include <config/tnlConfigDescription.h>
+#include <config/tnlParameterContainer.h>
+#include <matrix/tnlCSRMatrix.h>
+//#include "../../src/matrix/tnlCSRMatrix.h"
+#include "Quadcpp.h"
+
+int main(int argc, char* argv[]) {
+	tnlParameterContainer parameters;
+	tnlConfigDescription conf_desc;
+	if(conf_desc.ParseConfigDescription(CONFIG_FILE) != 0)
+		return EXIT_FAILURE;
+	if(!ParseCommandLine(argc, argv, conf_desc, parameters)) {
+		conf_desc.PrintUsage(argv[ 0 ]);
+		return EXIT_FAILURE;
+	}
+
+	tnlString inputFile = parameters.GetParameter <tnlString> ("input-file");
+	tnlFile binaryFile;
+	if(! binaryFile.open(inputFile, tnlReadMode)) {
+		cerr << "I am not able to open the file " << inputFile << "." << endl;
+		return 1;
+	}
+	tnlCSRMatrix <double> doubleMatrix("double");
+	if(! doubleMatrix.load(binaryFile)) {
+		cerr << "Unable to restore the CSR matrix." << endl;
+		return 1;
+	}
+	binaryFile.close();
+	
+	tnlCSRMatrix <QuadDouble> quadMatrix("quad");
+	//quadMatrix = doubleMatrix;
+	return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/examples/quad-test/quad-test.cfg.desc b/examples/quad-test/quad-test.cfg.desc
new file mode 100644
index 0000000000..637dcc048a
--- /dev/null
+++ b/examples/quad-test/quad-test.cfg.desc
@@ -0,0 +1,22 @@
+group IO
+{
+   string input-file            [Input file name.];
+   string output-file           [Output file name.];
+   real output-period           [Intervals for writing the state of the computation (in the meaning of parameter t).];
+},[Arguments describing input and output data.];
+group Problem
+{
+   real final-t              [When reaching this t the computation will stop.];
+
+},[Setting up the problem we solve.];
+group Method
+{
+   string method             [Method for solving the problem.];
+},[Parameters controling the method we use.];
+group Solver
+{
+   string  solver-name;
+   real    max-solver-res( 1.0e-6 ); 
+   integer max-solver-iterations( 1000000 );
+},[Parameters of the solver];
+
diff --git a/install b/install
deleted file mode 100755
index f681b003f8..0000000000
--- a/install
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-
-TARGET=TNL
-INSTALL_PREFIX=${HOME}/local
-WITH_CUDA=no
-WITH_CUSPARSE=no
-CUDA_ARCHITECTURE=2.0
-TEMPLATE_EXPLICIT_INSTANTIATION=yes
-VERBOSE=1
-
-CMAKE="cmake"
-CPUS=`grep -c processor /proc/cpuinfo`
-
-echo "Building $TARGET using $CPUS processors."
-
-if [ ! -d Debug ];
-then
-   mkdir Debug
-fi
-if [ ! -d Release ];
-then
-   mkdir Release
-fi
-
-cd Debug
-${CMAKE} .. -DCMAKE_BUILD_TYPE=Debug \
-            -DCMAKE_INSTALL_PREFIX=${HOME}/local \
-            -DCUDA_ARCHITECTURE=${CUDA_ARCHITECTURE} \
-            -DWITH_CUDA=${WITH_CUDA} \
-            -DWITH_CUSPARSE=${WITH_CUSPARSE} \
-            -DPETSC_DIR=${PETSC_DIR} \
-            -DWITH_TEMPLATE_EXPLICIT_INSTANTIATION=${TEMPLATE_EXPLICIT_INSTANTIATION}
-make -j${CPUS} #VERBOSE=1
-make -j${CPUS} test
-make -j${CPUS} install
-
-cd ../Release
-${CMAKE} .. -DCMAKE_INSTALL_PREFIX=${HOME}/local \
-            -DCUDA_ARCHITECTURE=${CUDA_ARCHITECTURE} \
-            -DWITH_CUDA=${WITH_CUDA} \
-            -DWITH_CUSPARSE=${WITH_CUSPARSE} \
-            -DPETSC_DIR=${PETSC_DIR} \
-            -DWITH_TEMPLATE_EXPLICIT_INSTANTIATION=${TEMPLATE_EXPLICIT_INSTANTIATION}
-make -j${CPUS} #VERBOSE=1
-make -j${CPUS} test
-make -j${CPUS} install
diff --git a/install b/install
new file mode 120000
index 0000000000..ab759d74a7
--- /dev/null
+++ b/install
@@ -0,0 +1 @@
+/usr/local/share/automake-1.11/INSTALL
\ No newline at end of file
-- 
GitLab