Scheduler: Added better support for += and -= in vector expressions and fixed minor bugs along the line.
Scheduler: Homogenization of statement_node members. Now only three members: {lhs, op, rhs}

This simplifies interfaces quite a bit and provides better encapsulation.
Mapping old members of statement_node to new members:
 lhs_type        -> lhs.type
 lhs_type_family -> lhs.type_family
 lhs.{union}     -> lhs.{union}    (no change)
 op_type         -> op.type
 op_family       -> op.type_family
 rhs_type        -> rhs.type
 rhs_type_family -> rhs.type_family
 rhs.{union}     -> rhs.{union}    (no change)

type and type_family could also be unified, but the current mechanism is considered sufficient.
Eventual changes at some later state could be reasonably well dealt with using string substitution.
Scheduler: Added better processing of matrix expressions.

Now the same set of operations as for vectors is supported.
Unification possible -> next step.
Updated scheduler benchmark to reflect a more involved vector operation.

x = y + z replaced by x = alpha * y + beta * z, which involves more dispatching.
Overhead still below 0.5us on my Desktop machine, hence small compared to kernel launch overhead.
Fixed test for global variables.

double may not be available on OpenCL devices, thus causing the test to fail without something being broken.
Fixed wrong return type of memory handle for circulant_matrix and hankel_matrix
Introduced viennacl::context() as a generic context unifying OpenCL contexts and CUDA streams/devices.

So far available in the constructors of vectors only. Extension to matrices to come.
Added optional context parameter to matrix and scalar types.

backend::memory_create now requires a context parameter in order to help a quick transition.
Fixed wrong output stream for vectors and vector operations
Applied context to matrix and scalar types.

For verification, solverbench-opencl now runs entirely within a separate context, which is not equal to the default context.
This way, multi-threading and concurrent multi-GPU-usage for independent systems is now possible.
Integrated the new version of the generator.

Includes minor change in ViennaCL's core : additional predicates and symbolic_{vector,matrix}_base
BLAS1, BLAS2 and BLAS3 are supported, but the set of operators supported for BLAS1 is very limited for now. More tests are comming.
Autotuning is not yet reimplemented, even though a wide range of profiles have been tested
Added async_copy() for vectors. Use like fast_copy().

Allow for overlapping host<->device communications with computations.
Added benchmark for host<->device copy performance.

Compares viennacl::copy(), viennacl::fast_copy(), viennacl::async_copy()
Merge branch 'master' of github.com:viennacl/viennacl-dev

Conflicts:
	examples/benchmarks/CMakeLists.txt
Merge remote-tracking branch 'upstream/master' into pyviennacl
add some test scripts for my own benefit
* Split out package into modules -- still need to add logging stuff (in util)
* Generalise the Vector class and supporting structures for multiple dtypes
* Add a check to ensure that dtypes in an expression are the same
   -- but also add support for the later ability in ViennaCL to cast dtypes
* Add functions for printing expression statements
* Add scalar-vector multiplication

Immediate TODO: Logging; clean up code/logic; comments;
                generalise get_vector_result_size
Need to support generic Python float and int; hmm..