C++ Mathematical Expression Library (ExprTk) http://www.partow.net/programming/exprtk/index.html
diff --git a/exprtk.hpp b/exprtk.hpp index fca963e..33c681b 100644 --- a/exprtk.hpp +++ b/exprtk.hpp
@@ -4734,6 +4734,11 @@ return vector_size(); } + inline value_ptr data() const + { + return value_at(0); + } + protected: virtual value_ptr value_at(const std::size_t&) const = 0; @@ -4814,11 +4819,6 @@ : vector_holder_base_(new(buffer)sequence_vector_impl<Allocator,std::vector>(vec)) {} - template <typename Allocator> - vector_holder(std::deque<Type,Allocator>& deq) - : vector_holder_base_(new(buffer)sequence_vector_impl<Allocator,std::deque>(deq)) - {} - inline value_ptr operator[](const std::size_t& index) const { return (*vector_holder_base_)[index]; @@ -4829,6 +4829,11 @@ return vector_holder_base_->size(); } + inline value_ptr data() const + { + return vector_holder_base_->data(); + } + private: mutable vector_holder_base* vector_holder_base_; @@ -6683,12 +6688,12 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = vec1_node_ptr_->ref(); + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = vec1_node_ptr_->ref().data(); for (std::size_t i = 0; i < vec_size_; ++i) { - std::swap((*vec0[i]),(*vec1[i])); + std::swap(vec0[i],vec1[i]); } return vec1_node_ptr_->value(); @@ -8677,37 +8682,38 @@ { if (vec_node_ptr_) { - vector_holder<T>& vec_hldr = vec_node_ptr_->ref(); const T v = binary_node<T>::branch_[1].first->value(); + T* vec = vec_node_ptr_->ref().data(); + loop_unroll::details lud(vec_size_); int i = 0; for (; i < lud.upper_bound; i += lud.batch_size) { - (*vec_hldr[i ]) = v; - (*vec_hldr[i + 1]) = v; - (*vec_hldr[i + 2]) = v; - (*vec_hldr[i + 3]) = v; + vec[i ] = v; + vec[i + 1] = v; + vec[i + 2] = v; + vec[i + 3] = v; #ifndef exprtk_disable_superscalar_unroll - (*vec_hldr[i + 4]) = v; - (*vec_hldr[i + 5]) = v; - (*vec_hldr[i + 6]) = v; - (*vec_hldr[i + 7]) = v; + vec[i + 4] = v; + vec[i + 5] = v; + vec[i + 6] = v; + vec[i + 7] = v; #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : (*vec_hldr[i++]) = v; - case 6 : (*vec_hldr[i++]) = v; - case 5 : (*vec_hldr[i++]) = v; - case 4 : (*vec_hldr[i++]) = v; + case 7 : vec[i++] = v; + case 6 : vec[i++] = v; + case 5 : vec[i++] = v; + case 4 : vec[i++] = v; #endif - case 3 : (*vec_hldr[i++]) = v; - case 2 : (*vec_hldr[i++]) = v; - case 1 : (*vec_hldr[i++]) = v; + case 3 : vec[i++] = v; + case 2 : vec[i++] = v; + case 1 : vec[i++] = v; } return vec_node_ptr_->value(); @@ -8794,37 +8800,37 @@ if (initialised_) { - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = vec1_node_ptr_->ref(); + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = vec1_node_ptr_->ref().data(); loop_unroll::details lud(vec_size_); int i = 0; for (; i < lud.upper_bound; i += lud.batch_size) { - (*vec0[i ]) = (*vec1[i ]); - (*vec0[i + 1]) = (*vec1[i + 1]); - (*vec0[i + 2]) = (*vec1[i + 2]); - (*vec0[i + 3]) = (*vec1[i + 3]); + vec0[i ] = vec1[i ]; + vec0[i + 1] = vec1[i + 1]; + vec0[i + 2] = vec1[i + 2]; + vec0[i + 3] = vec1[i + 3]; #ifndef exprtk_disable_superscalar_unroll - (*vec0[i + 4]) = (*vec1[i + 4]); - (*vec0[i + 5]) = (*vec1[i + 5]); - (*vec0[i + 6]) = (*vec1[i + 6]); - (*vec0[i + 7]) = (*vec1[i + 7]); + vec0[i + 4] = vec1[i + 4]; + vec0[i + 5] = vec1[i + 5]; + vec0[i + 6] = vec1[i + 6]; + vec0[i + 7] = vec1[i + 7]; #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : { (*vec0[i]) = (*vec1[i]); ++i; } - case 6 : { (*vec0[i]) = (*vec1[i]); ++i; } - case 5 : { (*vec0[i]) = (*vec1[i]); ++i; } - case 4 : { (*vec0[i]) = (*vec1[i]); ++i; } + case 7 : { vec0[i] = vec1[i]; ++i; } + case 6 : { vec0[i] = vec1[i]; ++i; } + case 5 : { vec0[i] = vec1[i]; ++i; } + case 4 : { vec0[i] = vec1[i]; ++i; } #endif - case 3 : { (*vec0[i]) = (*vec1[i]); ++i; } - case 2 : { (*vec0[i]) = (*vec1[i]); ++i; } - case 1 : { (*vec0[i]) = (*vec1[i]); ++i; } + case 3 : { vec0[i] = vec1[i]; ++i; } + case 2 : { vec0[i] = vec1[i]; ++i; } + case 1 : { vec0[i] = vec1[i]; ++i; } } return vec0_node_ptr_->value(); @@ -8962,37 +8968,38 @@ { if (vec_node_ptr_) { - vector_holder<T>& vec_hldr = vec_node_ptr_->ref(); const T v = binary_node<T>::branch_[1].first->value(); + T* vec = vec_node_ptr_->ref().data(); + loop_unroll::details lud(vec_size_); int i = 0; for (; i < lud.upper_bound; i += lud.batch_size) { - Operation::assign(*vec_hldr[i ],v); - Operation::assign(*vec_hldr[i + 1],v); - Operation::assign(*vec_hldr[i + 2],v); - Operation::assign(*vec_hldr[i + 3],v); + Operation::assign(vec[i ],v); + Operation::assign(vec[i + 1],v); + Operation::assign(vec[i + 2],v); + Operation::assign(vec[i + 3],v); #ifndef exprtk_disable_superscalar_unroll - Operation::assign(*vec_hldr[i + 4],v); - Operation::assign(*vec_hldr[i + 5],v); - Operation::assign(*vec_hldr[i + 6],v); - Operation::assign(*vec_hldr[i + 7],v); + Operation::assign(vec[i + 4],v); + Operation::assign(vec[i + 5],v); + Operation::assign(vec[i + 6],v); + Operation::assign(vec[i + 7],v); #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : Operation::assign((*vec_hldr[i++]),v); - case 6 : Operation::assign((*vec_hldr[i++]),v); - case 5 : Operation::assign((*vec_hldr[i++]),v); - case 4 : Operation::assign((*vec_hldr[i++]),v); + case 7 : Operation::assign(vec[i++],v); + case 6 : Operation::assign(vec[i++],v); + case 5 : Operation::assign(vec[i++],v); + case 4 : Operation::assign(vec[i++],v); #endif - case 3 : Operation::assign((*vec_hldr[i++]),v); - case 2 : Operation::assign((*vec_hldr[i++]),v); - case 1 : Operation::assign((*vec_hldr[i++]),v); + case 3 : Operation::assign(vec[i++],v); + case 2 : Operation::assign(vec[i++],v); + case 1 : Operation::assign(vec[i++],v); } return vec_node_ptr_->value(); @@ -9080,14 +9087,14 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = vec1_node_ptr_->ref(); + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = vec1_node_ptr_->ref().data(); loop_unroll::details lud(vec_size_); int i = 0; - #define exprtk_loop(N) \ - (*vec0[i + N]) = Operation::process((*vec0[i + N]),*vec1[i + N]); \ + #define exprtk_loop(N) \ + vec0[i + N] = Operation::process(vec0[i + N],vec1[i + N]); \ for (; i < lud.upper_bound; i += lud.batch_size) { @@ -9211,12 +9218,12 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = vec1_node_ptr_->ref(); + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = vec1_node_ptr_->ref().data(); for (std::size_t i = 0; i < vec_size_; ++i) { - if (std::equal_to<T>()(T(0),Operation::process(*vec0[i],*vec1[i]))) + if (std::equal_to<T>()(T(0),Operation::process(vec0[i],vec1[i]))) { return T(0); } @@ -9299,11 +9306,11 @@ binary_node<T>::branch_[0].first->value(); T v = binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec_hldr = vec_node_ptr_->ref(); + T* vec = vec_node_ptr_->ref().data(); for (std::size_t i = 0; i < vec_size_; ++i) { - if (std::equal_to<T>()(T(0),Operation::process(*vec_hldr[i],v))) + if (std::equal_to<T>()(T(0),Operation::process(vec[i],v))) { return T(0); } @@ -9384,11 +9391,11 @@ T v = binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec_hldr = vec_node_ptr_->ref(); + T* vec = vec_node_ptr_->ref().data(); for (std::size_t i = 0; i < vec_size_; ++i) { - if (std::equal_to<T>()(T(0),Operation::process(v,*vec_hldr[i]))) + if (std::equal_to<T>()(T(0),Operation::process(v,vec[i]))) { return T(0); } @@ -9504,15 +9511,15 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = vec1_node_ptr_->ref(); - vector_holder<T>& vec2 = *temp_; + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = vec1_node_ptr_->ref().data(); + T* vec2 = (*temp_).data(); loop_unroll::details lud(vec_size_); int i = 0; - #define exprtk_loop(N) \ - (*vec2[i + N]) = Operation::process((*vec0[i + N]),(*vec1[i + N])); \ + #define exprtk_loop(N) \ + vec2[i + N] = Operation::process(vec0[i + N],vec1[i + N]); \ for (; i < lud.upper_bound; i += lud.batch_size) { @@ -9539,7 +9546,7 @@ #undef exprtk_loop - return *vec2[0]; + return vec2[0]; } else return std::numeric_limits<T>::quiet_NaN(); @@ -9635,14 +9642,14 @@ binary_node<T>::branch_[0].first->value(); const T v = binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = *temp_; + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = (*temp_).data(); loop_unroll::details lud(vec_size_); int i = 0; - #define exprtk_loop(N) \ - (*vec1[i + N]) = Operation::process((*vec0[i + N]),v); \ + #define exprtk_loop(N) \ + vec1[i + N] = Operation::process(vec0[i + N],v); \ for (; i < lud.upper_bound; i += lud.batch_size) { @@ -9669,7 +9676,7 @@ #undef exprtk_loop - return *vec1[0]; + return vec1[0]; } else return std::numeric_limits<T>::quiet_NaN(); @@ -9763,14 +9770,14 @@ const T v = binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - vector_holder<T>& vec1 = vec1_node_ptr_->ref(); - vector_holder<T>& vec2 = *temp_; + T* vec1 = vec1_node_ptr_->ref().data(); + T* vec2 = (*temp_).data(); loop_unroll::details lud(vec_size_); int i = 0; - #define exprtk_loop(N) \ - (*vec2[i + N]) = Operation::process(v,(*vec1[i + N])); \ + #define exprtk_loop(N) \ + vec2[i + N] = Operation::process(v,vec1[i + N]); \ for (; i < lud.upper_bound; i += lud.batch_size) { @@ -9797,7 +9804,7 @@ #undef exprtk_loop - return *vec2[0]; + return vec2[0]; } else return std::numeric_limits<T>::quiet_NaN(); @@ -9888,40 +9895,40 @@ if (vec0_node_ptr_) { - vector_holder<T>& vec0 = vec0_node_ptr_->ref(); - vector_holder<T>& vec1 = *temp_; + T* vec0 = vec0_node_ptr_->ref().data(); + T* vec1 = (*temp_).data(); loop_unroll::details lud(vec_size_); int i = 0; for (; i < lud.upper_bound; i += lud.batch_size) { - (*vec1[i ]) = Operation::process((*vec0[i ])); - (*vec1[i + 1]) = Operation::process((*vec0[i + 1])); - (*vec1[i + 2]) = Operation::process((*vec0[i + 2])); - (*vec1[i + 3]) = Operation::process((*vec0[i + 3])); + vec1[i ] = Operation::process(vec0[i ]); + vec1[i + 1] = Operation::process(vec0[i + 1]); + vec1[i + 2] = Operation::process(vec0[i + 2]); + vec1[i + 3] = Operation::process(vec0[i + 3]); #ifndef exprtk_disable_superscalar_unroll - (*vec1[i + 4]) = Operation::process((*vec0[i + 4])); - (*vec1[i + 5]) = Operation::process((*vec0[i + 5])); - (*vec1[i + 6]) = Operation::process((*vec0[i + 6])); - (*vec1[i + 7]) = Operation::process((*vec0[i + 7])); + vec1[i + 4] = Operation::process(vec0[i + 4]); + vec1[i + 5] = Operation::process(vec0[i + 5]); + vec1[i + 6] = Operation::process(vec0[i + 6]); + vec1[i + 7] = Operation::process(vec0[i + 7]); #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } - case 6 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } - case 5 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } - case 4 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } + case 7 : { vec1[i] = Operation::process(vec0[i]); ++i; } + case 6 : { vec1[i] = Operation::process(vec0[i]); ++i; } + case 5 : { vec1[i] = Operation::process(vec0[i]); ++i; } + case 4 : { vec1[i] = Operation::process(vec0[i]); ++i; } #endif - case 3 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } - case 2 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } - case 1 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; } + case 3 : { vec1[i] = Operation::process(vec0[i]); ++i; } + case 2 : { vec1[i] = Operation::process(vec0[i]); ++i; } + case 1 : { vec1[i] = Operation::process(vec0[i]); ++i; } } - return *vec1[0]; + return vec1[0]; } else return std::numeric_limits<T>::quiet_NaN(); @@ -11816,27 +11823,28 @@ static inline T process(const ivector_ptr v) { - vector_holder<T>& vec = v->vec()->ref(); + const T* vec = v->vec()->ref().data(); + const std::size_t vec_size = v->vec()->ref().size(); - loop_unroll::details lud(vec.size()); + loop_unroll::details lud(vec_size); int i = 0; - if (vec.size() <= static_cast<std::size_t>(lud.batch_size)) + if (vec_size <= static_cast<std::size_t>(lud.batch_size)) { T result = T(0); - switch (vec.size()) + switch (vec_size) { #ifndef exprtk_disable_superscalar_unroll - case 8 : result += (*vec[i++]); - case 7 : result += (*vec[i++]); - case 6 : result += (*vec[i++]); - case 5 : result += (*vec[i++]); + case 8 : result += vec[i++]; + case 7 : result += vec[i++]; + case 6 : result += vec[i++]; + case 5 : result += vec[i++]; #endif - case 4 : result += (*vec[i++]); - case 3 : result += (*vec[i++]); - case 2 : result += (*vec[i++]); - case 1 : result += (*vec[i++]); + case 4 : result += vec[i++]; + case 3 : result += vec[i++]; + case 2 : result += vec[i++]; + case 1 : result += vec[i++]; } return result; @@ -11846,29 +11854,29 @@ for (; i < lud.upper_bound; i += lud.batch_size) { - r[0] += (*vec[i ]); - r[1] += (*vec[i + 1]); - r[2] += (*vec[i + 2]); - r[3] += (*vec[i + 3]); + r[0] += vec[i ]; + r[1] += vec[i + 1]; + r[2] += vec[i + 2]; + r[3] += vec[i + 3]; #ifndef exprtk_disable_superscalar_unroll - r[4] += (*vec[i + 4]); - r[5] += (*vec[i + 5]); - r[6] += (*vec[i + 6]); - r[7] += (*vec[i + 7]); + r[4] += vec[i + 4]; + r[5] += vec[i + 5]; + r[6] += vec[i + 6]; + r[7] += vec[i + 7]; #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : r[0] += (*vec[i++]); - case 6 : r[0] += (*vec[i++]); - case 5 : r[0] += (*vec[i++]); - case 4 : r[0] += (*vec[i++]); + case 7 : r[0] += vec[i++]; + case 6 : r[0] += vec[i++]; + case 5 : r[0] += vec[i++]; + case 4 : r[0] += vec[i++]; #endif - case 3 : r[0] += (*vec[i++]); - case 2 : r[0] += (*vec[i++]); - case 1 : r[0] += (*vec[i++]); + case 3 : r[0] += vec[i++]; + case 2 : r[0] += vec[i++]; + case 1 : r[0] += vec[i++]; } return (r[0] + r[1] + r[2] + r[3]) @@ -11886,27 +11894,28 @@ static inline T process(const ivector_ptr v) { - vector_holder<T>& vec = v->vec()->ref(); + const T* vec = v->vec()->ref().data(); + const std::size_t vec_size = v->vec()->ref().size(); - loop_unroll::details lud(vec.size()); + loop_unroll::details lud(vec_size); int i = 0; - if (vec.size() <= static_cast<std::size_t>(lud.batch_size)) + if (vec_size <= static_cast<std::size_t>(lud.batch_size)) { T result = T(1); - switch (vec.size()) + switch (vec_size) { #ifndef exprtk_disable_superscalar_unroll - case 8 : result *= (*vec[i++]); - case 7 : result *= (*vec[i++]); - case 6 : result *= (*vec[i++]); - case 5 : result *= (*vec[i++]); + case 8 : result *= vec[i++]; + case 7 : result *= vec[i++]; + case 6 : result *= vec[i++]; + case 5 : result *= vec[i++]; #endif - case 4 : result *= (*vec[i++]); - case 3 : result *= (*vec[i++]); - case 2 : result *= (*vec[i++]); - case 1 : result *= (*vec[i++]); + case 4 : result *= vec[i++]; + case 3 : result *= vec[i++]; + case 2 : result *= vec[i++]; + case 1 : result *= vec[i++]; } return result; @@ -11916,29 +11925,29 @@ for (; i < lud.upper_bound; i += lud.batch_size) { - r[0] *= (*vec[i ]); - r[1] *= (*vec[i + 1]); - r[2] *= (*vec[i + 2]); - r[3] *= (*vec[i + 3]); + r[0] *= (vec[i ]); + r[1] *= (vec[i + 1]); + r[2] *= (vec[i + 2]); + r[3] *= (vec[i + 3]); #ifndef exprtk_disable_superscalar_unroll - r[4] *= (*vec[i + 4]); - r[5] *= (*vec[i + 5]); - r[6] *= (*vec[i + 6]); - r[7] *= (*vec[i + 7]); + r[4] *= (vec[i + 4]); + r[5] *= (vec[i + 5]); + r[6] *= (vec[i + 6]); + r[7] *= (vec[i + 7]); #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : r[0] *= (*vec[i++]); - case 6 : r[0] *= (*vec[i++]); - case 5 : r[0] *= (*vec[i++]); - case 4 : r[0] *= (*vec[i++]); + case 7 : r[0] *= (vec[i++]); + case 6 : r[0] *= (vec[i++]); + case 5 : r[0] *= (vec[i++]); + case 4 : r[0] *= (vec[i++]); #endif - case 3 : r[0] *= (*vec[i++]); - case 2 : r[0] *= (*vec[i++]); - case 1 : r[0] *= (*vec[i++]); + case 3 : r[0] *= (vec[i++]); + case 2 : r[0] *= (vec[i++]); + case 1 : r[0] *= (vec[i++]); } return (r[0] * r[1] * r[2] * r[3]) @@ -11956,41 +11965,42 @@ static inline T process(const ivector_ptr v) { - vector_holder<T>& vec = v->vec()->ref(); + const T* vec = v->vec()->ref().data(); + const std::size_t vec_size = v->vec()->ref().size(); T result = T(0); - loop_unroll::details lud(vec.size()); + loop_unroll::details lud(vec_size); int i = 0; for (; i < lud.upper_bound; i += lud.batch_size) { - result += (*vec[i]); - result += (*vec[i + 1]); - result += (*vec[i + 2]); - result += (*vec[i + 3]); + result += vec[i ]; + result += vec[i + 1]; + result += vec[i + 2]; + result += vec[i + 3]; #ifndef exprtk_disable_superscalar_unroll - result += (*vec[i + 4]); - result += (*vec[i + 5]); - result += (*vec[i + 6]); - result += (*vec[i + 7]); + result += vec[i + 4]; + result += vec[i + 5]; + result += vec[i + 6]; + result += vec[i + 7]; #endif } switch (lud.remainder) { #ifndef exprtk_disable_superscalar_unroll - case 7 : result += (*vec[i++]); - case 6 : result += (*vec[i++]); - case 5 : result += (*vec[i++]); - case 4 : result += (*vec[i++]); + case 7 : result += vec[i++]; + case 6 : result += vec[i++]; + case 5 : result += vec[i++]; + case 4 : result += vec[i++]; #endif - case 3 : result += (*vec[i++]); - case 2 : result += (*vec[i++]); - case 1 : result += (*vec[i++]); + case 3 : result += vec[i++]; + case 2 : result += vec[i++]; + case 1 : result += vec[i++]; } - return result / vec.size(); + return result / vec_size; } }; @@ -12001,13 +12011,14 @@ static inline T process(const ivector_ptr v) { - vector_holder<T>& vec = v->vec()->ref(); + const T* vec = v->vec()->ref().data(); + const std::size_t vec_size = v->vec()->ref().size(); - T result = (*vec[0]); + T result = vec[0]; - for (std::size_t i = 1; i < vec.size(); ++i) + for (std::size_t i = 1; i < vec_size; ++i) { - T v_i = (*vec[i]); + T v_i = vec[i]; if (v_i < result) result = v_i; @@ -12024,13 +12035,14 @@ static inline T process(const ivector_ptr v) { - vector_holder<T>& vec = v->vec()->ref(); + const T* vec = v->vec()->ref().data(); + const std::size_t vec_size = v->vec()->ref().size(); - T result = (*vec[0]); + T result = vec[0]; - for (std::size_t i = 1; i < vec.size(); ++i) + for (std::size_t i = 1; i < vec_size; ++i) { - T v_i = (*vec[i]); + T v_i = vec[i]; if (v_i > result) result = v_i; } @@ -15968,19 +15980,6 @@ return local_data().vector_store.add(vector_name,v); } - template <typename Allocator> - inline bool add_vector(const std::string& vector_name, std::deque<T,Allocator>& v) - { - if (!valid()) - return false; - else if (!valid_symbol(vector_name)) - return false; - else if (symbol_exists(vector_name)) - return false; - else - return local_data().vector_store.add(vector_name,v); - } - inline bool remove_variable(const std::string& variable_name, const bool delete_node = true) { if (!valid())
diff --git a/exprtk_test.cpp b/exprtk_test.cpp index 7003572..994f681 100644 --- a/exprtk_test.cpp +++ b/exprtk_test.cpp
@@ -4223,6 +4223,8 @@ "var x[3] := {-1,-2,-3}; sum(abs(x) ) == 6", "var x[3] := {0.1,0.2,0.3}; sum(trunc(x)) == 0", + "var x[10^6]:=[2];var y[10^6]:=[3]; var s:=0;equal(for(var i:=0; i<10;i+=1){s+= sum(5 *(2x-y/3)) + i;},150000045.0)", + "var x := 2; (~{ for (var i := 0; i < 10; i += 1) { for (var j := 0; j <= i; " "j += 1) { var y := 3; if ((i + j + y + x) < 6) { y += x; continue; } else " "break[i + j]; } } } + ~{ for (var i := 0; i < 10; i += 1) { for (var j := 0; "
diff --git a/readme.txt b/readme.txt index b1c84d3..4e3ba87 100644 --- a/readme.txt +++ b/readme.txt
@@ -622,11 +622,12 @@ (2) Vector Type -The vector type is a fixed size sequence of scalar values. A vector -can be indexed resulting in a scalar value. Operations between a -vector and scalar will result in a vector with a size equal to that of -the original vector, whereas operations between vectors will result in -a vector of size equal to that of the smaller of the two. +The vector type is a fixed size sequence of contiguous scalar values. +A vector can be indexed resulting in a scalar value. Operations +between a vector and scalar will result in a vector with a size equal +to that of the original vector, whereas operations between vectors +will result in a vector of size equal to that of the smaller of the +two. (3) String Type