Merge v0.2.0 to stable

* feat: add sketch for Vector2 class

* test: add assertTrue function

* fix: typo error

* feat: replace Vector2 with vector templates

* feat: replace vector templates with dynamic vectors

* test: add vector test to build

* test: add assertError function

* chore: replace GNU++11 with standard C++11

* feat: optimize and add vector operations

* test: extend vector tests

* doc: add equal function

* chore: fix build status url

* chore: update license to 2016

* chore: fix build status image

* chore: fix formatting

* doc: add constant and typedef comments

* fix: remove unused includes

* doc: vector operation doc

* feat: add vector unary minus operator

* test: add scalar multiplication and inversion tests

* test: extend assertError message

* test: add vector dot product tests

* test: fix message format

* test: add vector cross product tests

* test: add vector sum operation tests

* feat: add vector norm and length operations

* fix: remove unnessecary includes

* feat: add vector to_string operation

* fix: block operations for null-sized tuples

* test: add vector norm operation tests

* fix: minimize function overhead

* fix: root bug

* fix: add error message

* test: add vector length tests

* feature: reduce copying of constants

* doc: add vector guide to README

Author: Lennart

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Mooxmirror
+Copyright (c) 2016 Lennart Espe
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

Makefile

@@ -1,15 +1,15 @@
 # Compiler flags
-CFLAGS=-I./include -std=gnu++11 -Wall
-CFLAGS_LIB=-I./include -std=gnu++11 -c
-CFLAGS_TEST=test/tmath_test.cpp build/libtmath.a
+CFLAGS=-I./include -std=c++11 -Wall
+CFLAGS_LIB=-I./include -std=c++11 -c
+CFLAGS_TEST=./build/libtmath.a test/tmath_test.cpp
 
 all: lib test
 	@echo Done.
 
 lib: build_folder tmath.o
 	ar rcs build/libtmath.a build/tmath.o
 
-test: test_sine test_cosine test_tangent test_cosecant test_cotangent test_secant test_rad_deg test_abs test_factorial test_roots test_power test_exp_log
+test: test_sine test_cosine test_tangent test_cosecant test_cotangent test_secant test_rad_deg test_abs test_factorial test_roots test_power test_exp_log test_vectors
 	@echo all tests passed
 
 build_folder:
@@ -66,6 +66,10 @@ test_exp_log: test_folder
 	$(CC) $(CFLAGS) test/exp-log/test.cpp -o build/test/exp-log $(CFLAGS_TEST)
 	@build/test/exp-log
 
+test_vectors: test_folder
+	$(CC) $(CFLAGS) test/vectors/test.cpp -o build/test/vectors $(CFLAGS_TEST)
+	@build/test/vectors
+
 tmath.o: build_folder
 	$(CC) $(CFLAGS_LIB) src/tmath.cpp -o build/tmath.o
 

README.md

@@ -1,4 +1,4 @@
-# TMath [![Build status](https://travis-ci.org/mooxmirror/tmath.svg?branch=stable)](https://travis-ci.org/mooxmirror/tmath)
+# TMath [![Build status](https://travis-ci.org/lnsp/tmath.svg?branch=stable)](https://travis-ci.org/lnsp/tmath)
 A small math function collection based on the Taylor expansion series.
 
 ## Building the project
@@ -12,50 +12,71 @@ A small math function collection based on the Taylor expansion series.
 Just build it as described above, include the header files and link the library. The library uses the types `TMath::DOUBLE`(`long double`) and `TMath::LONG`(`long long`) for parameters and return values.
 
 ## What is included?
+### Mathematical functions
 
-Function                   | Description
-:------------------------: | ---------------------------------------
-`sin(DOUBLE x)`            | sine of x
-`asin(DOUBLE x)`           | arcsine of x
-`sinh(DOUBLE x)`           | hyperbolic sine of x
-`cos(DOUBLE x)`            | cosine of x
-`acos(DOUBLE x)`           | arccosine of x
-`cosh(DOUBLE x)`           | hyperbolic cosine of x
-`tan(DOUBLE x)`            | tangent of x
-`atan(DOUBLE x)`           | arctangent of x
-`cot(DOUBLE x)`            | cotangent of x
-`acot(DOUBLE x)`           | arccotangent of x
-`coth(DOUBLE x)`           | hyperbolic cotangent of x
-`sec(DOUBLE x)`            | secant of x
-`asec(DOUBLE x)`           | arcsecant of x
-`sech(DOUBLE x)`           | hyperbolic secant of x
-`cosec(DOUBLE x)`          | cosecant of x
-`acsc(DOUBLE x)`           | arccosecant of x
-`csch(DOUBLE x)`           | hyperbolic cosecant of x
-`floor(DOUBLE x)`          | next lower integer of x
-`ceil(DOUBLE x)`           | next higher integer of x
-`mod(LONG x, LONG y)`      | the remainder of the division x / y
-`exp(DOUBLE x)`            | natural exponential function
-`sqrt(DOUBLE x)`           | squareroot of x
-`root(DOUBLE x, DOUBLE n)` | n-th root of x
-`ln(DOUBLE x)`             | natural logarithm of x
-`lg(DOUBLE x)`             | common logarithm of x
-`lb(DOUBLE x)`             | binary logarithm of x
-`log(DOUBLE x, DOUBLE n)`  | logarithm with base n of x
-`pow(DOUBLE x, DOUBLE n)`  | x to the power of n
-`pow(LONG x, LONG n)`      | x to the power of n
-`pow(DOUBLE x, LONG n)`    | x to the power of n
-`fac(LONG n)`              | factorial of n
-`facd(LONG n)`             | factorial of n using floating point
-`oddfac(LONG n)`           | odd-factorial of n
-`oddfacd(LONG n)`          | odd-factorial of n using floating point
-`rad(DOUBLE x)`            | degrees to radiant
-`deg(DOUBLE x)`            | radiant to degrees
-`abs(DOUBLE x)`            | absolute value of x
+Function                                | Description
+:-------------------------------------: | ---------------------------------------------------------
+`sin(DOUBLE x)`                         | sine of x
+`asin(DOUBLE x)`                        | arcsine of x
+`sinh(DOUBLE x)`                        | hyperbolic sine of x
+`cos(DOUBLE x)`                         | cosine of x
+`acos(DOUBLE x)`                        | arccosine of x
+`cosh(DOUBLE x)`                        | hyperbolic cosine of x
+`tan(DOUBLE x)`                         | tangent of x
+`atan(DOUBLE x)`                        | arctangent of x
+`cot(DOUBLE x)`                         | cotangent of x
+`acot(DOUBLE x)`                        | arccotangent of x
+`coth(DOUBLE x)`                        | hyperbolic cotangent of x
+`sec(DOUBLE x)`                         | secant of x
+`asec(DOUBLE x)`                        | arcsecant of x
+`sech(DOUBLE x)`                        | hyperbolic secant of x
+`cosec(DOUBLE x)`                       | cosecant of x
+`acsc(DOUBLE x)`                        | arccosecant of x
+`csch(DOUBLE x)`                        | hyperbolic cosecant of x
+`floor(DOUBLE x)`                       | next lower integer of x
+`ceil(DOUBLE x)`                        | next higher integer of x
+`mod(LONG x, LONG y)`                   | the remainder of the division x / y
+`exp(DOUBLE x)`                         | natural exponential function
+`sqrt(DOUBLE x)`                        | squareroot of x
+`root(DOUBLE x, DOUBLE n)`              | n-th root of x
+`ln(DOUBLE x)`                          | natural logarithm of x
+`lg(DOUBLE x)`                          | common logarithm of x
+`lb(DOUBLE x)`                          | binary logarithm of x
+`log(DOUBLE x, DOUBLE n)`               | logarithm with base n of x
+`pow(DOUBLE x, DOUBLE n)`               | x to the power of n
+`pow(LONG x, LONG n)`                   | x to the power of n
+`pow(DOUBLE x, LONG n)`                 | x to the power of n
+`fac(LONG n)`                           | factorial of n
+`facd(LONG n)`                          | factorial of n using floating point
+`oddfac(LONG n)`                        | odd-factorial of n
+`oddfacd(LONG n)`                       | odd-factorial of n using floating point
+`rad(DOUBLE x)`                         | degrees to radiant
+`deg(DOUBLE x)`                         | radiant to degrees
+`abs(DOUBLE x)`                         | absolute value of x
+`equal(DOUBLE x, DOUBLE y)`             | floating-point number equality
+`equal(DOUBLE x, DOUBLE y, DOUBLE eps)` | floating-point number equality with a variance of epsilon
+
+### Vector class
+To initialize a new vector just use initializer lists (like `Vector {1, 2, 3}`) or create a null-vector using `Vector(n)` (where n is the number of dimensions).
+
+Operation       | Description
+--------------- | -------------------------------------------------------------
+`a[n]`          | Access the n-th element of the vector `a`
+`a + b`         | Adds vector `a` and `b`
+`a - b`         | Subtracts vector `a` from `b`
+`a * s`         | Scales the vector by the factor `s`
+`a / s`         | Scales the vector by the factor `1 / s`
+`a == b`        | Tests if vector `a` is equal to `b`
+`a != b`        | Tests if vector `a` is not equal to `b`
+`a.equal(b, e)` | Tests if the vector `a` is equal to `b` with the accuracy `e`
+`a.dot(b)`      | Dot product of `a` and `b`.
+`a.cross(b)`    | Cross product of `a` and `b`
+`a.norm()`      | Normalized copy of the vector `a`
+`a.length()`    | Length of vector `a`
+`a.dim()`       | Dimensions of vector `a`
+`a.to_string()` | Generates a string representation of the vector `a`
 
 ## What is planned?
 - Statistics (planned for v0.3)
-- Vectors (planned for v0.2)
-- Matrices (planned for v0.2)
-- Vector operations (planned for v0.2)
-- Matrix operations (planned for v0.2)
+- Matrices (planned for v0.3)
+- Matrix operations (planned for v0.3)

include/tmath.hpp

@@ -1,61 +1,105 @@
 #ifndef _TMATH_HPP
 #define _TMATH_HPP
 
+#include <vector>
+#include <initializer_list>
+#include <string>
+
 namespace TMath {
+// Shortform for long long
 typedef long long LONG;
+// Shortform for long double
 typedef long double DOUBLE;
+// A estimation of Pi
 const DOUBLE PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286;
+// A estimation of e
 const DOUBLE E =  2.718281828459045235360287471352662497757247093699959574966967627724076630354;
+// Constant for equality comparison for floating point numbers
+const DOUBLE EQUAL_EPSILON = 1e-7;
+// Mismatched dimensions error for vectors and matrices
+const std::string DIMENSION_ERROR = "Mismatched dimensions";
+// Error if the operation is not applicable
+const std::string BAD_OPERATION = "Operation is not applicable";
+// Vector length is equal to zero
+const std::string ZERO_LENGTH = "Vector has length 0";
+
+LONG floor(const DOUBLE&);
+LONG ceil(const DOUBLE&);
+DOUBLE mod(const DOUBLE&, const DOUBLE&);
 
-LONG floor(DOUBLE x);
-LONG ceil(DOUBLE x);
-DOUBLE mod(DOUBLE x, DOUBLE y);
+DOUBLE sin(const DOUBLE&);  // sine
+DOUBLE asin(const DOUBLE&);  // arcsine
+DOUBLE sinh(const DOUBLE&);  // hyperbolic sine
 
-DOUBLE sin(DOUBLE x);  // sine
-DOUBLE asin(DOUBLE x);  // arcsine
-DOUBLE sinh(DOUBLE x);  // hyperbolic sine
+DOUBLE cos(const DOUBLE&);  // cosine
+DOUBLE acos(const DOUBLE&);  // arccosine
+DOUBLE cosh(const DOUBLE&);  //hyperbolic cosine
 
-DOUBLE cos(DOUBLE x);  // cosine
-DOUBLE acos(DOUBLE x);  // arccosine
-DOUBLE cosh(DOUBLE x);  //hyperbolic cosine
+DOUBLE tan(const DOUBLE&);  // tangent
+DOUBLE atan(const DOUBLE&);  // arctangent
+DOUBLE tanh(const DOUBLE&);  // hyperbolic tangent
 
-DOUBLE tan(DOUBLE x);  // tangent
-DOUBLE atan(DOUBLE x);  // arctangent
-DOUBLE tanh(DOUBLE x);  // hyperbolic tangent
+DOUBLE cot(const DOUBLE&);  // cotangent
+DOUBLE acot(const DOUBLE&);  // arccotangent
+DOUBLE coth(const DOUBLE&);  // hyperbolic cotangent
 
-DOUBLE cot(DOUBLE x);  // cotangent
-DOUBLE acot(DOUBLE x);  // arccotangent
-DOUBLE coth(DOUBLE x);  // hyperbolic cotangent
+DOUBLE sec(const DOUBLE&);  // secant
+DOUBLE asec(const DOUBLE&);  // arcsecant
+DOUBLE sech(const DOUBLE&);  // hyperbolic secant
 
-DOUBLE sec(DOUBLE x);  // secant
-DOUBLE asec(DOUBLE x);  // arcsecant
-DOUBLE sech(DOUBLE x);  // hyperbolic secant
+DOUBLE csc(const DOUBLE&);  // cosecant
+DOUBLE acsc(const DOUBLE&);  // arccosecant
+DOUBLE csch(const DOUBLE&);  // hyperbolic cosecant
 
-DOUBLE csc(DOUBLE x);  // cosecant
-DOUBLE acsc(DOUBLE x);  // arccosecant
-DOUBLE csch(DOUBLE x);  // hyperbolic cosecant
+DOUBLE rad(const DOUBLE&);  // degrees to radians
+DOUBLE deg(const DOUBLE&);  // radians to degrees
 
-DOUBLE rad(DOUBLE deg);  // degrees to radians
-DOUBLE deg(DOUBLE rad);  // radians to degrees
+DOUBLE exp(const DOUBLE&);
+DOUBLE sqrt(const DOUBLE&);
+DOUBLE root(const DOUBLE&, const DOUBLE&);
+DOUBLE ln(const DOUBLE&);
+DOUBLE lg(const DOUBLE&);
+DOUBLE lb(const DOUBLE&);
+DOUBLE log(const DOUBLE&, const DOUBLE&);
 
-DOUBLE exp(DOUBLE x);
-DOUBLE sqrt(DOUBLE x);
-DOUBLE root(DOUBLE x, DOUBLE n);
-DOUBLE ln(DOUBLE x);
-DOUBLE lg(DOUBLE x);
-DOUBLE lb(DOUBLE x);
-DOUBLE log(DOUBLE x, DOUBLE n);
+DOUBLE pow(const DOUBLE&, const DOUBLE&);
+DOUBLE pow(const DOUBLE&, const LONG&);
+LONG pow(const LONG&, const LONG&);
 
-DOUBLE pow(DOUBLE x, DOUBLE n);
-DOUBLE pow(DOUBLE x, LONG n);
-LONG pow(LONG x, LONG n);
+LONG fac(const LONG&);
+DOUBLE facd(const LONG&);
+LONG oddfac(const LONG&);
+DOUBLE oddfacd(const LONG&);
 
-LONG fac(LONG n);
-DOUBLE facd(LONG n);
-LONG oddfac(LONG n);
-DOUBLE oddfacd(LONG n);
+DOUBLE abs(const DOUBLE&);
+DOUBLE equal(const DOUBLE&, const DOUBLE&);
+DOUBLE equal(const DOUBLE&, const DOUBLE&, const DOUBLE&);
 
-DOUBLE abs(DOUBLE x);
+class Vector {
+private:
+	std::vector<DOUBLE> elements;
+	int checkDimensions(const Vector&) const;
+public:
+	Vector(std::initializer_list<DOUBLE> list) : elements(list) {}
+	Vector(const int& d) : elements(d) {}
+	Vector(const Vector& v) : elements(v.elements) {};
+	DOUBLE& operator[](const int&);
+	Vector operator+(const Vector&) const;
+	Vector operator-() const;
+	Vector operator-(const Vector&) const;
+	Vector operator*(const DOUBLE&) const;
+	Vector operator/(const DOUBLE&) const;
+	bool equal(const Vector&, const DOUBLE&) const;
+	bool operator==(const Vector&) const;
+	bool operator!=(const Vector&) const;
+	DOUBLE dot(const Vector&) const;
+	Vector cross(const Vector&) const;
+	DOUBLE sum() const;
+	Vector norm() const;
+	DOUBLE length() const;
+	int dim() const;
+	std::string to_string() const;
+};
 }
 
 #endif

include/tmath_test.hpp

@@ -2,13 +2,16 @@
 #define _TMATH_TEST_HPP
 
 #include <string>
+#include <functional>
 #include "tmath.hpp"
 
 namespace TMathTest {
 const TMath::DOUBLE DEFAULT_TOLERANCE = 0.001;
 bool equal(TMath::DOUBLE x, TMath::DOUBLE y, TMath::DOUBLE tolerance);
 void assert(TMath::DOUBLE value, TMath::DOUBLE correct, std::string expression);
 void assert(TMath::DOUBLE value, TMath::DOUBLE correct, std::string expression, TMath::DOUBLE tolerance);
+void assertTrue(bool b, std::string expression);
+void assertError(std::function<void ()>, std::string expression);
 }
 
 #endif