Dev

doc/wiki/Main_Page.mwiki

@@ -20,7 +20,7 @@ various variants of matrix transpositions, interleaving loads/stores, optimized
 compile-time shuffling instructions, etc. Each of these are implemented in the
 most efficient manner for the target instruction set. Finally, it's possible
 to fall back to native intrinsics when necessary, without compromising
-maintanability.
+maintainability.
 
 
 The library sits somewhere in the middle between programming directly in
@@ -173,6 +173,32 @@ the compiler will generate.
 {{ltt|misc/prefetch_read}}  {{ltt|misc/prefetch_write}}
 </div>
 
+'''[[Algorithm | STL like algorithm]]'''
+<div class="mainpagediv">
+{{ltt|algorithm/any_of}}<br/>
+{{ltt|algorithm/all_of}}<br/>
+{{ltt|algorithm/copy}}<br/>
+{{ltt|algorithm/copy_n}}<br/>
+{{ltt|algorithm/count}}<br/>
+{{ltt|algorithm/count_if}}<br/>
+{{ltt|algorithm/equal}}<br/>
+{{ltt|algorithm/fill}}<br/>
+{{ltt|algorithm/find}}<br/>
+{{ltt|algorithm/find_if}}<br/>
+{{ltt|algorithm/find_if_not}}<br/>
+{{ltt|algorithm/lexicographical_compare}}<br/>
+{{ltt|algorithm/max}}<br/>
+{{ltt|algorithm/max_element}}<br/>
+{{ltt|algorithm/min}}<br/>
+{{ltt|algorithm/min_element}}<br/>
+{{ltt|algorithm/none_of}}<br/>
+{{ltt|algorithm/reduce}}<br/>
+{{ltt|algorithm/replace}}<br/>
+{{ltt|algorithm/replace_if}}<br/>
+{{ltt|algorithm/transform}}<br/>
+{{ltt|algorithm/transform_reduce}}<br/>
+</div>
+
 |- class="row rowbottom"
 | colspan=4|
 |}

doc/wiki/algorithm/all_of.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|all_of}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+   template<typename T, typename UnaryPredicate>
+      bool all_of(T const* first, T const* last, UnaryPredicate pred);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|all_of}} Checks if unary predicate p returns true for {{tt|all}} elements in the range {{tt|[first, last)}}. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | pred | unary predicate
+{{par end}}
+
+===Return value===
+{{tt|true}} if unary predicate returns {{tt|true}} for all elements in the range, {{tt|false}} otherwise. Returns {{tt|true}} if the range is empty.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc none_of}}
+{{dsc inc | algorithm/dsc any_of}}
+{{dsc end}}

doc/wiki/algorithm/any_of.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|any_of}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+   template<typename T, typename UnaryPredicate>
+      bool any_of(T const* first, T const* last, UnaryPredicate pred);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|all_of}} Checks if unary predicate p returns true for {{tt|at least one}} element in the range {{tt|[first, last)}}. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | pred | unary predicate
+{{par end}}
+
+===Return value===
+{{tt|true}} if unary predicate returns {{tt|true}} for at least one element in the range, {{tt|false}} otherwise. Returns {{tt|false}} if the range is empty.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc none_of}}
+{{dsc inc | algorithm/dsc all_of}}
+{{dsc end}}

doc/wiki/algorithm/copy.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|copy}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+   template<typename T> 
+            T* copy(T const* first, T const* last, T* out)
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|copy}} Copies the elements in the range, defined by {{tt|[first, last)}}, to another range beginning at {{tt|out}}. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to copy}}
+{{par | out | the beginning of the destination range.}}
+{{par end}}
+
+===Return value===
+Output adress to the element in the destination range, one past the last element copied.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc fill}}
+{{dsc inc | algorithm/dsc copy_n}}
+{{dsc end}}

doc/wiki/algorithm/copy_n.mwiki

@@ -0,0 +1,28 @@
+{{simdpp/title|copy}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+    template<typename T, typename Size> 
+      T* copy_n(T const* first, Size n, T* out)
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|copy_n}} Copies exactly {{tt|Size}} values from the range beginning at {{tt|first}} to the range beginning at {{tt|out}}, if {{tt|count>0}}. Does nothing otherwise.
+
+===Parameters===
+{{par begin}}
+{{par | first | the beginning of the range of elements to copy from}}
+{{par | Size | number of the elements to copy}}
+{{par | out | the beginning of the destination range}}
+{{par end}}
+
+===Return value===
+Output adress in the destination range, pointing past the last element copied if {{tt|Size>0}} or {{tt|out}} otherwise.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc fill}}
+{{dsc inc | algorithm/dsc copy}}
+{{dsc end}}

doc/wiki/algorithm/count.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|count}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+  template<typename T, typename U>
+    typename std::iterator_traits<const T*>::difference_type
+      count(T const* first, T const* last, U val);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|count}} counts the elements that are equal to value in the range defined by {{tt|[first, last)}}. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | val | the value to search for}}
+{{par end}}
+
+===Return value===
+number of elements satisfying the condition.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc count_if}}
+{{dsc end}}

doc/wiki/algorithm/count_if.mwiki

@@ -0,0 +1,28 @@
+{{simdpp/title|count_if}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+  template<typename T, typename UnaryPredicate>
+    typename std::iterator_traits<const T*>::difference_type
+      count_if(T const* first, T const* last, UnaryPredicate pred);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|count_if}} counts the elements that satisfied the predicate in the range defined by {{tt|[first, last)}}. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | pred | unary predicate which returns {{tt|true}} for the required elements. }}
+{{par end}}
+
+===Return value===
+number of elements satisfying the condition.
+
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc count}}
+{{dsc end}}

doc/wiki/algorithm/equal.mwiki

@@ -0,0 +1,35 @@
+{{simdpp/title|equal}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | num=1 |
+  template<typename T> 
+    bool equal(const T* first1,  const T* last1, const T* first2);
+}}
+{{dcl | num=2 |
+  template<typename T, typename BinaryPredicate> 
+    bool equal(const T* first1,  const T* last1, const T* first2,BinaryPredicate pred);
+
+}}
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|equal}} Returns {{c|true}} if the range {{tt|[first1,last1)}} is equal to the range {{tt|[first2, first2 + (last1 - first1))}} according to pred and {{c|false}} otherwise
+
+@1@ Returns {{c|true}} if the range {{tt|[first1,last1)}} is equal to the range {{tt|[first2, first2 + (last1 - first1))}}, and {{c|false}} otherwise
+@2@ The binary operation BinaryPredicate is applied to pairs of elements from two ranges: one defined by [first1, last1) and the other beginning at first2.
+
+===Parameters===
+{{par begin}}
+{{par | first1, last1 | the first range of elements to examine}
+{{par | first2 | the beginning of the second range of elements to examine}}
+{{par | pred | 	binary predicate which returns ​true if the elements should be treated as equal.}}
+{{par end}}
+
+===Return value===
+If the elements in the two ranges are equal, returns  {{c|true}}.Otherwise returns  {{c|false}}.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc find }}
+{{dsc inc | algorithm/dsc lexicographic_compare }}
+{{dsc end}}

doc/wiki/algorithm/fill.mwiki

@@ -0,0 +1,26 @@
+{{simdpp/title|fill}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+  template<typename T, typename U> 
+        void fill(T* first, T* last, U value)
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|fill}} Assigns the given {{tt|value}} to the elements in the range {{tt|[first, last)}}.
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to modify}}
+{{par | value | the value to be assigned}}
+{{par end}}
+
+===Return value===
+(none)
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc copy}}
+{{dsc end}}

doc/wiki/algorithm/find.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|find}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+    template<typename T, typename U>
+        T const* find(T const* first, T const* last, U val);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|find}} Returns the first element in the range [first, last[ that equal val. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | value | value to compare the elements to.}}
+{{par end}}
+
+===Return value===
+Address to the first element satisfying the condition or last if no such element is found.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc find_if}}
+{{dsc inc | algorithm/dsc find_if_not}}
+{{dsc end}}

doc/wiki/algorithm/find_if.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|find_if}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+  template<typename T, typename UnaryPredicate>
+    T const* find_if(T const* first, T const* last, UnaryPredicate pred);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|find_if}} Returns the first element in the range [first, last[ that satisfies specific predicate. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | pred | unary predicate which returns {{true}} for the required element.}}
+{{par end}}
+
+===Return value===
+Address to the first element satisfying the condition or last if no such element is found.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc find}}
+{{dsc inc | algorithm/dsc find_if_not}}
+{{dsc end}}

doc/wiki/algorithm/find_if_not.mwiki

@@ -0,0 +1,27 @@
+{{simdpp/title|find_if_not}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | 
+  template<typename T, typename UnaryPredicate>
+    T const* find_if_not(T const* first, T const* last, UnaryPredicate pred);
+}}
+
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|find_if}} Returns the first element in the range [first, last[ that {{not}} satisfies specific predicate. 
+
+===Parameters===
+{{par begin}}
+{{par | first, last | the range of elements to examine}}
+{{par | pred | unary predicate which returns {{false}} for the required element.}}
+{{par end}}
+
+===Return value===
+Address to the first element satisfying the condition or last if no such element is found.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc find}}
+{{dsc inc | algorithm/dsc find_if}}
+{{dsc end}}

doc/wiki/algorithm/lexicographical_compare.mwiki

@@ -0,0 +1,34 @@
+{{simdpp/title|lexicographical_compare}}
+{{misc/navbar}}
+{{dcl begin}}
+{{dcl | num=1 |
+      template<typename T>
+         bool lexicographical_compare(const T* first1, const T* last1, const T* first2, const T* last2);
+}}
+{{dcl | num=2 |
+
+      template<typename T, typename BinarayPredicate>
+         bool lexicographical_compare(const T* first1, const T* last1, const T* first2, const T* last2,BinarayPredicate comp);
+}}
+{{dcl end}}
+{{misc/navbar}}
+
+{{tt|lexicographical_compare}} Checks if the first range {{c|[first1, last1)}} is lexicographically ''less'' than the second range {{c|[first2, last2)}}. 
+
+@1@ Elements are compared using {{tt|operator<}}.
+@2@ Elements are compared using the given binary comparison function {{tt|comp}}.
+
+===Parameters===
+{{par begin}}
+{{par | first1, last1 | the first range of elements to examine}}
+{{par | first2, last2 | the second range of elements to examine}}
+{{par | comp | comparaison operator}}
+{{par end}}
+
+===Return value===
+{{c|true}} if the first range is lexicographically ''less'' than the second.
+
+===See also===
+{{dsc begin}}
+{{dsc inc | algorithm/dsc equal }}
+{{dsc end}}