├── README.md
├── lazyexpr.h
├── lazyops.h
└── lazyval.h


/README.md:
--------------------------------------------------------------------------------
 1 | # LazyVal
 2 | Header only expression template interface for vector types in C++.
 3 | ## What can this do ?
 4 | 1) Do straightforward arithmetic operations with vector types (class only needs constructor(size), size() and operator[] methods) using operator overloading (+,-,*,/)  
 5 | 2) Lazy evaluate only the needed results (no internal caching). Other than that, you can chain expresssions to your liking, without any additional runtime cost !  
 6 | Here is example of what you can do:  
 7 | ```cpp
 8 | #include "lazyval.h"
 9 | using namespace Lazy;
10 | auto a = std::vector<float>(48, 6);
11 | // Create templated symbolic expression tree
12 | auto t = 4 * (a + a + a + a + 4) / std::vector<float>(48, 6);
13 | // Evaluate only t[4]
14 | std::cout << t[4];
15 | // Evaluate the whole vector, use this if you need to cache/get all the results.
16 | std::vector<float> v = t;
17 | ```
18 | ## Basics
19 | The size is always equal to the smallest vector in the whole expression tree. Scalars apply to all elements, but don't affect the size.  
20 | For forced evaluation or conversion, please use either conversion operator or eval<T>() member method.  
21 | If you want to apply a lambda over 1 - 3 operands, use map() functions.  
22 | Ternary operator is possible using cond() function.  
23 | ## Requirements
24 | Works with C++17 and GCC, Clang. (Maybe MSVC too...)  
25 | 


--------------------------------------------------------------------------------
/lazyexpr.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | #include <cmath>
 4 | #include <tuple>
 5 | #include <algorithm>
 6 | #include "lazyops.h"
 7 | namespace Lazy {
 8 | 
 9 | 	template <typename Op, typename ...Ts>
10 | 	struct NaryExpr {
11 | 
12 | 		template<typename T>
13 | 		using NotInit = std::negation<std::is_same<T, std::initializer_list<typename T::value_type>>>;
14 | 		template <typename T>
15 | 		using IfScalar = std::is_scalar<typename std::remove_reference<T>::type>;
16 | 
17 | 		std::tuple<Ts...> args;
18 | 		const Op op; // = Op();
19 | 		// Uncomment if you want... There is really no need
20 | 		//NaryExpr(Ts && ... _args) : args(std::forward<Ts>(_args)...) {}
21 | 		NaryExpr(Op&& op, Ts && ... _args) : args(std::forward<Ts>(_args)...), op(std::forward<Op>(op)) {}
22 | 
23 | 		inline size_t size() const {
24 | 			const auto call = [](Ts const& ... arg) { return std::min({ size_wrapper(arg)... }); };
25 | 			return std::apply(call, args);
26 | 		}
27 | 
28 | 		template <typename Tres, typename = std::enable_if_t<NotInit<Tres>::value>>
29 | 		inline operator Tres() const { return eval<Tres>(); }
30 | 
31 | 		template <typename Tres>
32 | 		inline Tres eval() const {
33 | 			size_t res_size = size();
34 | 			res_size = res_size == size_t(-1) ? 1 : res_size;
35 | 			auto res = Tres(res_size);
36 | 			for(size_t i = 0; i < res_size; i++)
37 | 				res[i] = operator[](i);
38 | 			return res;
39 | 		}
40 | 
41 | 		inline auto operator[](size_t i)const {
42 | 			const auto call = [op = this->op, i](Ts const& ... arg) { return op(index_wrapper(arg, i)...); };
43 | 			return std::apply(call, args);
44 | 		}
45 | 
46 | 		template <typename T>
47 | 		static auto index_wrapper(const T& val, size_t i) {
48 | 			if constexpr(IfScalar<T>::value)
49 | 				return val;
50 | 			else return val[i];
51 | 		}
52 | 
53 | 		template <typename T>
54 | 		static size_t size_wrapper(const T& val) {
55 | 			if constexpr(IfScalar<T>::value)
56 | 				return size_t(-1);
57 | 			else return val.size();
58 | 		}
59 | 
60 | 	};
61 | 
62 | 	template <typename Op, typename T1>
63 | 	using UnExpr = NaryExpr<Op, T1>;
64 | 	template <typename Op, typename T1, typename T2>
65 | 	using BinExpr = NaryExpr<Op, T1, T2>;
66 | 	template <typename Op, typename T1, typename T2, typename T3>
67 | 	using TerExpr = NaryExpr<Op, T1, T2, T3>;
68 | }


--------------------------------------------------------------------------------
/lazyops.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <cmath>
  3 | namespace Lazy{
  4 | 	// Ternary ops
  5 | 	struct OpCond {
  6 | 		template <typename T1, typename T2, typename T3>
  7 | 		inline auto operator()(const T1& e1, const T2& e2, const T3& e3) const {
  8 | 			return e1 ? e2 : e3;
  9 | 		}
 10 | 	};
 11 | 	struct OpLim {
 12 | 		template <typename T1, typename T2, typename T3>
 13 | 		inline auto operator()(const T1& e1, const T2& e2, const T3& e3) const {
 14 | 			return std::min(std::max(e1, T1(e2)), T1(e3));
 15 | 		}
 16 | 	};
 17 | 	// Binary ops
 18 | 	struct OpMul {
 19 | 		template <typename T1, typename T2>
 20 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 21 | 			return e1 * e2;
 22 | 		}
 23 | 	};
 24 | 	struct OpSub {
 25 | 		template <typename T1, typename T2>
 26 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 27 | 			return e1 - e2;
 28 | 		}
 29 | 	};
 30 | 	struct OpDiv {
 31 | 		template <typename T1, typename T2>
 32 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 33 | 			return e1 / e2;
 34 | 		}
 35 | 	};
 36 | 	struct OpAdd {
 37 | 		template <typename T1, typename T2>
 38 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 39 | 			return e1 + e2;
 40 | 		}
 41 | 	};
 42 | 	struct OpEq {
 43 | 		template <typename T1, typename T2>
 44 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 45 | 			return e1 == e2;
 46 | 		}
 47 | 	};
 48 | 	struct OpNeq {
 49 | 		template <typename T1, typename T2>
 50 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 51 | 			return e1 != e2;
 52 | 		}
 53 | 	};
 54 | 	struct OpGt {
 55 | 		template <typename T1, typename T2>
 56 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 57 | 			return e1 > e2;
 58 | 		}
 59 | 	};
 60 | 	struct OpLt {
 61 | 		template <typename T1, typename T2>
 62 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 63 | 			return e1 < e2;
 64 | 		}
 65 | 	};
 66 | 	struct OpGte {
 67 | 		template <typename T1, typename T2>
 68 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 69 | 			return e1 >= e2;
 70 | 		}
 71 | 	};
 72 | 	struct OpLte {
 73 | 		template <typename T1, typename T2>
 74 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 75 | 			return e1 <= e2;
 76 | 		}
 77 | 	};
 78 | 	struct OpMin {
 79 | 		template <typename T1, typename T2>
 80 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 81 | 			return std::min(e1, T1(e2));
 82 | 		}
 83 | 	};
 84 | 	struct OpMax {
 85 | 		template <typename T1, typename T2>
 86 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 87 | 			return std::max(e1, T1(e2));
 88 | 		}
 89 | 	};
 90 | 	struct OpPow {
 91 | 		template <typename T1, typename T2>
 92 | 		inline auto operator()(const T1& e1, const T2& e2) const {
 93 | 			return std::pow(e1, e2);
 94 | 		}
 95 | 	};
 96 | 
 97 | 
 98 | 	// Unary ops
 99 | 	struct OpNeg {
100 | 		template <typename T1>
101 | 		inline auto operator()(const T1& e1) const {
102 | 			return -e1;
103 | 		}
104 | 	};
105 | 	struct OpSqrt {
106 | 		template <typename T1>
107 | 		inline auto operator()(const T1& e1) const {
108 | 			return std::sqrt(e1);
109 | 		}
110 | 	};
111 | 	struct OpExp {
112 | 		template <typename T1>
113 | 		inline auto operator()(const T1& e1) const {
114 | 			return std::exp(e1);
115 | 		}
116 | 	};
117 | 	struct OpLog2 {
118 | 		template <typename T1>
119 | 		inline auto operator()(const T1& e1) const {
120 | 			return std::log2(e1);
121 | 		}
122 | 	};
123 | 	struct OpLog {
124 | 		template <typename T1>
125 | 		inline auto operator()(const T1& e1) const {
126 | 			return std::log(e1);
127 | 		}
128 | 	};
129 | 	struct OpLog10 {
130 | 		template <typename T1>
131 | 		inline auto operator()(const T1& e1) const {
132 | 			return std::log10(e1);
133 | 		}
134 | 	};
135 | 	struct OpSqr {
136 | 		template <typename T1>
137 | 		inline auto operator()(const T1& e1) const {
138 | 			return e1 * e1;
139 | 		}
140 | 	};
141 | 	struct OpId {
142 | 		template <typename T1>
143 | 		inline auto operator()(const T1& e1) const {
144 | 			return e1;
145 | 		}
146 | 	};
147 | }


--------------------------------------------------------------------------------
/lazyval.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include "lazyexpr.h"
  3 | namespace Lazy {
  4 | 	//Ternary operands
  5 | 	template<typename U1, typename U2, typename U3>
  6 | 	inline auto cond(U1&& a, U2&& b, U3&& c) {
  7 | 		return NaryExpr<OpCond, U1, U2, U3>(OpCond(), std::forward<U1>(a), std::forward<U2>(b), std::forward<U3>(c));
  8 | 	}
  9 | 	template<typename U1, typename U2, typename U3>
 10 | 	inline auto limit(U1&& a, U2&& b, U3&& c) {
 11 | 		return NaryExpr<OpLim, U1, U2, U3>(OpLim(), std::forward<U1>(a), std::forward<U2>(b), std::forward<U3>(c));
 12 | 	}
 13 | 	template<typename U1, typename U2, typename U3, typename TeOp>
 14 | 	inline auto map(U1&& a, U2&& b, U3&& c, TeOp&& op = TeOp()) {
 15 | 		return NaryExpr<TeOp, U1, U2, U3>(std::forward<TeOp>(op), std::forward<U1>(a), std::forward<U2>(b), std::forward<U3>(c));
 16 | 	}
 17 | 	//Binary operands
 18 | 	template<typename U1, typename U2, typename BiOp>
 19 | 	inline auto map(U1&& a, U2&& b, BiOp&& op = BiOp()) {
 20 | 		return NaryExpr<BiOp, U1, U2>(std::forward<BiOp>(op), std::forward<U1>(a), std::forward<U2>(b));
 21 | 	}
 22 | 	template<typename U1, typename U2>
 23 | 	inline auto operator+(U1&& a, U2&& b) {
 24 | 		return NaryExpr<OpAdd, U1, U2>(OpAdd(), std::forward<U1>(a), std::forward<U2>(b));
 25 | 	}
 26 | 	template<typename U1, typename U2>
 27 | 	inline auto operator-(U1&& a, U2&& b) {
 28 | 		return NaryExpr<OpSub, U1, U2>(OpSub(), std::forward<U1>(a), std::forward<U2>(b));
 29 | 	}
 30 | 	template<typename U1, typename U2>
 31 | 	inline auto operator*(U1&& a, U2&& b) {
 32 | 		return NaryExpr<OpMul, U1, U2>(OpMul(), std::forward<U1>(a), std::forward<U2>(b));
 33 | 	}
 34 | 	template<typename U1, typename U2>
 35 | 	inline auto operator/(U1&& a, U2&& b) {
 36 | 		return NaryExpr<OpDiv, U1, U2>(OpDiv(), std::forward<U1>(a), std::forward<U2>(b));
 37 | 	}
 38 | 	template<typename U1, typename U2>
 39 | 	inline auto operator==(U1&& a, U2&& b) {
 40 | 		return NaryExpr<OpEq, U1, U2>(OpEq(), std::forward<U1>(a), std::forward<U2>(b));
 41 | 	}
 42 | 	template<typename U1, typename U2>
 43 | 	inline auto operator!=(U1&& a, U2&& b) {
 44 | 		return NaryExpr<OpNeq, U1, U2>(OpNeq(), std::forward<U1>(a), std::forward<U2>(b));
 45 | 	}
 46 | 	template<typename U1, typename U2>
 47 | 	inline auto operator>=(U1&& a, U2&& b) {
 48 | 		return NaryExpr<OpGte, U1, U2>(OpGte(), std::forward<U1>(a), std::forward<U2>(b));
 49 | 	}
 50 | 	template<typename U1, typename U2>
 51 | 	inline auto operator<=(U1&& a, U2&& b) {
 52 | 		return NaryExpr<OpLte, U1, U2>(OpLte(), std::forward<U1>(a), std::forward<U2>(b));
 53 | 	}
 54 | 	template<typename U1, typename U2>
 55 | 	inline auto operator<(U1&& a, U2&& b) {
 56 | 		return NaryExpr<OpLt, U1, U2>(OpLt(), std::forward<U1>(a), std::forward<U2>(b));
 57 | 	}
 58 | 	template<typename U1, typename U2>
 59 | 	inline auto operator>(U1&& a, U2&& b) {
 60 | 		return NaryExpr<OpGt, U1, U2>(OpGt(), std::forward<U1>(a), std::forward<U2>(b));
 61 | 	}
 62 | 	template<typename U1, typename U2>
 63 | 	inline auto min(U1&& a, U2&& b) {
 64 | 		return NaryExpr<OpMin, U1, U2>(OpMin(), std::forward<U1>(a), std::forward<U2>(b));
 65 | 	}
 66 | 	template<typename U1, typename U2>
 67 | 	inline auto max(U1&& a, U2&& b) {
 68 | 		return NaryExpr<OpMax, U1, U2>(OpMax(), std::forward<U1>(a), std::forward<U2>(b));
 69 | 	}
 70 | 	template<typename U1, typename U2>
 71 | 	inline auto pow(U1&& a, U2&& b) {
 72 | 		return NaryExpr<OpPow, U1, U2>(OpPow(), std::forward<U1>(a), std::forward<U2>(b));
 73 | 	}
 74 | 
 75 | 	// Unary operands
 76 | 	template<typename U1, typename UnOp>
 77 | 	inline auto map(U1&& a, UnOp&& op = UnOp()) {
 78 | 		return NaryExpr<UnOp, U1>(std::forward<UnOp>(op), std::forward<U1>(a));
 79 | 	}
 80 | 	template<typename U1>
 81 | 	inline auto operator-(U1&& a) {
 82 | 		return NaryExpr<OpNeg, U1>(OpNeg(),std::forward<U1>(a));
 83 | 	}
 84 | 	template<typename U1>
 85 | 	inline auto identity(U1&& a) {
 86 | 		return NaryExpr<OpId, U1>(OpId(), std::forward<U1>(a));
 87 | 	}
 88 | 	template<typename U1>
 89 | 	inline auto sqrt(U1&& a) {
 90 | 		return NaryExpr<OpSqrt, U1>(OpSqrt(), std::forward<U1>(a));
 91 | 	}
 92 | 	template<typename U1>
 93 | 	inline auto sqr(U1&& a) {
 94 | 		return NaryExpr<OpSqr, U1>(OpSqr(), std::forward<U1>(a));
 95 | 	}
 96 | 	template<typename U1>
 97 | 	inline auto exp(U1&& a) {
 98 | 		return NaryExpr<OpExp, U1>(OpExp(), std::forward<U1>(a));
 99 | 	}
100 | 	template<typename U1>
101 | 	inline auto log(U1&& a) {
102 | 		return NaryExpr<OpLog, U1>(OpLog(), std::forward<U1>(a));
103 | 	}
104 | 	template<typename U1>
105 | 	inline auto log2(U1&& a) {
106 | 		return NaryExpr<OpLog2, U1>(OpLog2(), std::forward<U1>(a));
107 | 	}
108 | 	template<typename U1>
109 | 	inline auto log10(U1&& a) {
110 | 		return NaryExpr<OpLog10, U1>(OpLog10(), std::forward<U1>(a));
111 | 	}
112 | }


--------------------------------------------------------------------------------