SigUtil  0.95
Utility modules for modern C++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
sig Namespace Reference

Namespaces

 impl
 

Classes

struct  AbsoluteError
 誤差基準（絶対誤差） More...
 
class  array
 STLライクな静的配列 More...
 
struct  assign_div_t
 compound_assignment の第1引数に指定する代入関数のプリセット（除算代入） More...
 
struct  assign_minus_t
 compound_assignment の第1引数に指定する代入関数のプリセット（減算代入） More...
 
struct  assign_mult_t
 compound_assignment の第1引数に指定する代入関数のプリセット（乗算代入） More...
 
struct  assign_plus_t
 compound_assignment の第1引数に指定する代入関数のプリセット（加算代入） More...
 
struct  BinaryDistance
 バイナリ距離 More...
 
struct  CanberraDistance
 キャンベラ距離 More...
 
struct  CosineSimilarity
 コサイン類似度（Cosine Similarity） More...
 
struct  decrement_t
 引数の値をデクリメントした値を返す関数オブジェクト More...
 
struct  div_t
 除法を行う関数オブジェクト More...
 
class  Histgram
 ヒストグラム More...
 
struct  identity_t
 引数の変数をそのまま返す関数オブジェクト More...
 
struct  increment_t
 引数の値をインクリメントした値を返す関数オブジェクト More...
 
struct  JS_Divergence
 JS情報量（Jensen-Shannon Divergence） More...
 
struct  KL_Divergence
 KL情報量（Kullback–Leibler Divergence） More...
 
struct  MahalanobisDistance
 
class  ManageConvergence
 収束判定の計算と管理を行うクラス More...
 
class  ManageConvergenceSimple
 収束判定の管理を行うクラス More...
 
struct  MaxNorm
 最大ノルム More...
 
struct  MinkowskiDistance
 ミンコフスキー距離 More...
 
struct  minus_t
 減法を行う関数オブジェクト More...
 
struct  mult_t
 乗法を行う関数オブジェクト More...
 
struct  Norm
 Pノルム More...
 
class  Percent
 パーセント型 More...
 
struct  plus_t
 加法を行う関数オブジェクト More...
 
struct  RelativeError
 誤差基準（相対誤差） More...
 
class  SimpleRandom
 初期化時に指定した範囲の一様分布乱数を発生させるクラス More...
 
class  TagDealer
 HTML風にタグをエンコード・デコードする More...
 
class  TimeWatch
 タイムウォッチ More...
 
class  ZenHanReplace
 全角・半角文字の置換処理を行う More...
 

Typedefs

template<class T >
using matrix_u = boost::numeric::ublas::matrix< T >
 
template<class T >
using vector_u = boost::numeric::ublas::vector< T >
 
using ManhattanDistance = MinkowskiDistance< 1 >
 
using EuclideanDistance = MinkowskiDistance< 2 >
 
template<class T >
using Maybe = boost::optional< T >
 
template<class R >
using IfsSelector = typename impl::SameIf< R, std::string, std::ifstream, std::wifstream >::type
 

Enumerations

enum  WriteMode { WriteMode::overwrite, WriteMode::append, WriteMode::overwrite, WriteMode::append }
 SaveLine, SaveNum の保存に関する設定 More...
 
enum  WriteMode { WriteMode::overwrite, WriteMode::append, WriteMode::overwrite, WriteMode::append }
 

Functions

template<class F , class C1 , class C2 , typename std::enable_if< impl::container_traits< C1 >::exist &&impl::container_traits< C2 >::exist >::type *& = enabler>
void compound_assignment (F &&assign_op, C1 &dest, C2 const &src)
 コンテナへの代入演算 (element-wise: container and container) More...
 
template<class F , class C , class T , typename std::enable_if< impl::container_traits< C >::exist &&!impl::container_traits< T >::exist >::type *& = enabler>
void compound_assignment (F &&assign_op, C &dest, T src)
 コンテナへの代入演算 (element-wise: container and scalar) More...
 
template<class R = void, class C = void>
auto sum (C const &data) -> typename impl::SameIf< R, void, typename impl::container_traits< C >::value_type, R >::type
 総和 More...
 
template<class R = void, class C = void, class Pred = void>
auto sum (C const &data, Pred const &access_func) -> typename impl::SameIf< R, void, decltype(impl::eval(access_func, std::declval< typename impl::container_traits< C >::value_type >())), R >::type
 総和 More...
 
template<class R = void, class CC = void>
auto sum_row (CC const &matrix, uint index)
 行列の指定行の総和 More...
 
template<class R = void, class CC = void>
auto sum_col (CC const &matrix, uint index)
 行列の指定列の総和 More...
 
template<class R = void, class C = void>
auto product (C const &data) -> typename impl::SameIf< R, void, typename impl::container_traits< C >::value_type, R >::type
 総乗 More...
 
template<class R = void, class C = void, class Pred = void>
auto product (C const &data, Pred const &access_func) -> typename impl::SameIf< R, void, decltype(impl::eval(access_func, std::declval< typename impl::container_traits< C >::value_type >())), R >::type
 総乗 More...
 
template<class R = void, class CC = void>
auto product_row (CC const &matrix, uint index)
 行列の指定行の総乗 More...
 
template<class R = void, class CC = void>
auto product_col (CC const &matrix, uint index)
 行列の指定列の総乗 More...
 
template<class C >
double average (C const &data)
 平均 More...
 
template<class C >
double variance (C const &data)
 分散 More...
 
template<class C , typename std::enable_if< std::is_floating_point< typename impl::container_traits< C >::value_type >::value >::type *& = enabler>
bool normalize (C &data)
 正規化（Normalization） More...
 
template<class R = double, class C = void>
auto normalize (C const &data, int dummy=0) -> typename impl::container_traits< C >::template rebind< R >
 正規化（Normalization） More...
 
template<class C , typename std::enable_if< std::is_floating_point< typename impl::container_traits< C >::value_type >::value >::type *& = enabler>
bool standardize (C &data)
 標準化(Standardization) More...
 
template<class R = double, class C = void>
auto standardize (C const &data, int dummy=0) -> typename impl::container_traits< C >::template rebind< R >
 標準化(Standardization) More...
 
template<class C , typename std::enable_if< std::is_floating_point< typename impl::container_traits< C >::value_type >::value >::type *& = enabler>
bool normalize_dist (C &data)
 確率分布の正規化 More...
 
template<class R = double, class C = void>
auto normalize_dist (C const &data, int dummy=0) -> typename impl::container_traits< C >::template rebind< R >
 確率分布の正規化 More...
 
template<class OP , class T1 , class T2 , typename std::enable_if< (!impl::container_traits< typename impl::remove_const_reference< T1 >::type >::exist)&&(!impl::container_traits< typename impl::remove_const_reference< T2 >::type >::exist) >::type *& = enabler>
auto binary_operation (OP &&func, T1 &&v1, T2 &&v2) -> typename impl::remove_const_reference< decltype(impl::eval(std::forward< OP >(func), std::forward< T1 >(v1), std::forward< T2 >(v2)))>::type
 二項演算 (scalar and scalar) More...
 
template<class OP , class C1 , class C2 , class CR1 = typename impl::remove_const_reference<C1>::type, class CR2 = typename impl::remove_const_reference<C2>::type, class AT1 = typename impl::forward_element<C1>::type, class AT2 = typename impl::forward_element<C2>::type, typename std::enable_if< impl::container_traits< CR1 >::exist &&impl::container_traits< CR2 >::exist >::type *& = enabler>
auto binary_operation (OP &&func, C1 &&c1, C2 &&c2) -> typename impl::container_traits< CR1 >::template rebind< typename impl::remove_const_reference< decltype(impl::eval(std::forward< OP >(func), std::declval< AT1 >(), std::declval< AT2 >()))>::type >
 二項演算 (element-wise: container and container) More...
 
template<class OP , class C , class T , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type, typename std::enable_if< impl::container_traits< CR >::exist &&(!impl::container_traits< typename impl::remove_const_reference< T >::type >::exist) >::type *& = enabler>
auto binary_operation (OP &&func, C &&c, T &&v) -> typename impl::container_traits< CR >::template rebind< typename impl::remove_const_reference< decltype(impl::eval(std::forward< OP >(func), std::declval< ET >(), v))>::type >
 二項演算 (element-wise: container and scalar) More...
 
template<class OP , class T , class C , class ET = typename impl::forward_element<C>::type, class CR = typename impl::remove_const_reference<C>::type, typename std::enable_if< (!impl::container_traits< typename impl::remove_const_reference< T >::type >::exist)&&impl::container_traits< CR >::exist >::type *& = enabler>
auto binary_operation (OP &&func, T &&v, C &&c) -> typename impl::container_traits< CR >::template rebind< typename impl::remove_const_reference< decltype(impl::eval(std::forward< OP >(func), v, std::declval< ET >()))>::type >
 二項演算 (element-wise: scalar and container) More...
 
template<class T1 , class T2 >
auto plus (T1 &&v1, T2 &&v2) -> decltype(binary_operation(plus_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 >
auto minus (T1 &&v1, T2 &&v2) -> decltype(binary_operation(minus_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 >
auto mult (T1 &&v1, T2 &&v2) -> decltype(binary_operation(mult_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 >
auto div (T1 &&v1, T2 &&v2) -> decltype(binary_operation(div_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto operator+ (T1 &&v1, T2 &&v2) -> decltype(binary_operation(plus_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto operator- (T1 &&v1, T2 &&v2) -> decltype(binary_operation(minus_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto operator* (T1 &&v1, T2 &&v2) -> decltype(binary_operation(mult_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto operator/ (T1 &&v1, T2 &&v2) -> decltype(binary_operation(div_t(), std::forward< T1 >(v1), std::forward< T2 >(v2)))
 
template<class F , class... Cs>
void for_each (F &&func, Cs &&...containers)
 複数コンテナを反復処理 More...
 
template<class F , class... Cs>
void for_each (F &&func, int init, Cs &&...containers)
 複数コンテナを反復処理 (添字変数の利用可) More...
 
template<class V , class R = std::vector<typename V::value_type>>
auto from_vector_ublas (V const &vec) -> R
 ublas::vector<T> から STLのvectorへ変換 More...
 
template<class M , class R = std::vector<typename M::value_type>>
auto from_matrix_ublas (M const &mat, uint row) -> R
 ublas::matrix<T> の指定行を STLのvectorへ変換 More...
 
template<class M , class R = std::vector<std::vector<typename M::value_type>>>
auto from_matrix_ublas (M const &mat) -> R
 ublas::matrix<T> から STLのvectorの2次元配列へ変換 More...
 
template<class C , class T = typename impl::container_traits<C>::value_type>
auto to_vector_ublas (C const &vec) -> vector_u< T >
 STLのvector から ublas::vector<T> へ変換 More...
 
template<class CC , class T = typename impl::container_traits<typename impl::container_traits<CC>::value_type>::value_type>
auto to_matrix_ublas (CC const &mat) -> matrix_u< T >
 STLのvectorの2次元配列 から ublas::matrix<T> へ変換 More...
 
template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto invert_matrix (matrix_u< T > &&mat) -> Maybe< matrix_u< RT >>
 逆行列を求める More...
 
template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto invert_matrix (matrix_u< T > const &mat) -> Maybe< matrix_u< RT >>
 
template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto matrix_vector_solve (matrix_u< T > &&mat, vector_u< T > &&vec) -> Maybe< vector_u< RT >>
 連立方程式を解く More...
 
template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto matrix_vector_solve (matrix_u< T > const &mat, vector_u< T > const &vec) -> Maybe< vector_u< RT >>
 
template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto matrix_vector_solve (matrix_u< T > const &mat, vector_u< T > &&vec) -> Maybe< vector_u< RT >>
 
template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto matrix_vector_solve (matrix_u< T > &&mat, vector_u< T > const &vec) -> Maybe< vector_u< RT >>
 
template<class F , class V >
auto map_v (F &&func, V &&vec)
 ベクトルの全要素に対して、値を返す関数を適用し、その結果のベクトルを返す More...
 
template<class F , class M >
auto map_m (F &&func, M &&mat)
 
template<class F , class V , class... Vs>
void for_each_v (F &&func, V &vec, Vs &&...vecs)
 ベクトルの全要素に対して、関数を適用する More...
 
template<class F , class M >
void for_each_m (F &&func, M &mat)
 行列の全要素に対して、代入演算を行う関数を適用する More...
 
template<class F , class M >
void for_diagonal (F &&func, M &mat)
 行列の対角要素の対して、代入演算を行う関数を適用する More...
 
template<class V , typename std::enable_if< std::is_floating_point< typename V::value_type >::value >::type *& = enabler>
bool normalize_dist_v (V &data)
 
template<class V >
auto normalize_dist_v (V const &data, int dummy=0)
 
template<class C1 , class C2 >
bool is_same_size (C1 const &v1, C2 const &v2)
 
template<class C1 , class C2 >
bool is_valid_distribution (C1 const &v1, C2 const &v2)
 離散確率分布の性質を満たしているか確認 More...
 
template<class C >
bool has_zero (C const &v)
 要素の値に0があるか確認 More...
 
template<class C1 , class C2 >
bool is_comparable (C1 const &v1, C2 const &v2, impl::NumericVectorTag)
 2つのベクトルが比較可能か確認 More...
 
template<class C1 , class C2 >
bool is_comparable (C1 const &v1, C2 const &v2, impl::DistributionTag)
 2つの確率分布が比較可能か確認 More...
 
auto modify_dirpass_tail (FilepassString const &directory_pass, bool const has_slash) -> FilepassString
 ディレクトリ・ファイルパスの末尾に'/'or'\'があるかチェックし、付けるか外すかどうかを指定して反映 More...
 
auto get_file_names (FilepassString const &directory_pass, bool hidden_file, std::wstring extension=L"") -> Maybe< std::vector< std::wstring >>
 指定ディレクトリにあるファイル名を取得 More...
 
auto get_folder_names (FilepassString const &directory_pass, bool hidden_file) -> Maybe< std::vector< std::wstring >>
 指定ディレクトリにあるフォルダ名を取得 More...
 
void clear_file (FilepassString const &file_pass)
 ファイル内容の初期化 More...
 
template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type>
auto filter (F &&pred, C &&list)
 コンテナから指定条件を満たす要素を抽出する More...
 
template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type>
auto filter (F &&pred, int init, C &&list)
 コンテナから指定条件を満たす要素を抽出する(反復回数を表すindexが利用できる) More...
 
template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type>
auto partition (F &&pred, C &&list)
 コンテナから指定条件を満たす要素とそれ以外の要素とを分離する More...
 
template<class F , class T , class C >
auto foldl (F &&func, T &&init, C &&list)
 コンテナの先頭からたたみ込み More...
 
template<class F , class T , class C >
auto foldr (F &&func, T &&init, C &&list)
 コンテナの末尾からたたみ込み More...
 
template<class F1 , class F2 , class T , class... Cs>
auto dotProduct (F1 &&fold_func, F2 &&oper_func, T &&init, Cs &&...lists)
 可変長個のコンテナに対して関数適用して結果を集約する関数 More...
 
template<class F , class C1 , class... Cs>
auto variadicZipWith (F &&func, C1 &&list1, Cs &&...lists)
 n引数高階関数 More...
 
template<class F , class C >
auto map (F &&func, C &&list)
 1引数高階関数 More...
 
template<class F , class C1 , class C2 >
auto zipWith (F &&func, C1 &&list1, C2 &&list2)
 2引数高階関数 More...
 
template<class T , class C = std::vector<T>>
auto replicate (uint n, T const &value) -> C
 値を複製したコンテナを返す More...
 
template<class C >
auto reverse (C &&list) -> typename impl::remove_const_reference< C >::type
 コンテナの要素の順番を逆転させたコンテナを返す More...
 
template<class C , class R = typename impl::remove_const_reference<C>::type, typename std::enable_if<!impl::static_container_traits< R >::exist >::type *& = enabler>
auto merge (C &&list1, C &&list2) -> R
 コンテナの結合（同じコンテナ型） More...
 
template<class R = void, class C1 , class C2 , class CR1 = typename impl::remove_const_reference<C1>::type, class CR2 = typename impl::remove_const_reference<C2>::type, class RT = typename std::common_type< typename impl::container_traits<CR1>::value_type, typename impl::container_traits<CR2>::value_type >::type, class RR = typename impl::SameIf<R, void, typename impl::remove_const_reference< typename impl::container_traits<CR1>::template rebind<RT>>::type, R >::type, class AT1 = typename impl::forward_element<C1>::type, class AT2 = typename impl::forward_element<C2>::type, typename std::enable_if<!(impl::static_container_traits< CR1 >::exist)>::type *& = enabler>
auto merge (C1 &&list1, C2 &&list2) -> RR
 
template<class R = void, class SC , class C , class SCR = typename impl::remove_const_reference<SC>::type, class CR = typename impl::remove_const_reference<C>::type, class RT = typename std::common_type< typename impl::static_container_traits<SCR>::value_type, typename impl::container_traits<CR>::value_type >::type, class RR = typename impl::SameIf<R, void, typename impl::remove_const_reference< typename impl::container_traits<CR>::template rebind<RT>>::type, R >::type, typename std::enable_if< impl::static_container_traits< SCR >::exist &&(!impl::static_container_traits< CR >::exist)>::type *& = enabler>
auto merge (SC &&list1, C &&list2) -> RR
 
template<class R = void, class SC1 , class SC2 , class SCR1 = typename impl::remove_const_reference<SC1>::type, class SCR2 = typename impl::remove_const_reference<SC2>::type, class RT = typename std::common_type< typename impl::static_container_traits<SCR1>::value_type, typename impl::static_container_traits<SCR2>::value_type >::type, class RR = typename impl::SameIf<R, void, typename impl::static_container_traits<SCR1>::template rebind_t<RT, impl::plus_t<impl::static_container_traits<SCR1>::size, impl::static_container_traits<SCR2>::size>::value>, R >::type, typename std::enable_if< impl::static_container_traits< SCR1 >::exist &&impl::static_container_traits< SCR2 >::exist >::type *& = enabler>
auto merge (SC1 &&list1, SC2 &&list2) -> RR
 
template<class C , class CR = typename impl::remove_const_reference<C>::type>
auto take (uint n, C &&list) -> CR
 コンテナの先頭からn個の要素を取り出す More...
 
template<class C , class CR = typename impl::remove_const_reference<C>::type>
auto drop (uint n, C &&list) -> CR
 コンテナの先頭からn個を削除したコンテナを返す More...
 
template<class T1 , class T2 , class TC = typename std::common_type<T1, T2>::type, class C = std::vector<TC>>
C seqn (T1 st, T2 d, uint n)
 等差数列 More...
 
template<class... Cs>
auto zip (Cs &&...lists)
 複数のコンテナから、タプルのコンテナを作る More...
 
template<uint Index, class CT , class T = typename std::tuple_element<Index, typename impl::container_traits<typename impl::remove_const_reference<CT>::type>::value_type>::type, class R = std::vector<T>>
auto unzip (CT &&list_tuple) -> R
 タプルのコンテナから、指定したindexのコンテナを取り出す More...
 
template<class CT >
auto unzip (CT &&c_tuple)
 タプルのコンテナから、コンテナのタプルを作る More...
 
template<class C , class F , class... Its>
void iterative_make (uint loop, C &dest, F &&func, Its...iterators)
 
template<class T , class F1 , class F2 , class... Its>
void iterative_fold (uint loop, T &dest, F1 &&zip, F2 &&fold, Its...iterators)
 
template<class F , class... Its>
void iterative_assign (uint loop, F &&func, Its...iterators)
 
template<class F , class... Its>
void iterative_assign (uint loop, int init, F &&func, Its...iterators)
 
template<class C >
void erase (C &container, typename impl::sequence_container_traits< C >::value_type const &t)
 
template<class C >
void erase (C &container, typename impl::associative_container_traits< C >::value_type const &t)
 
template<class C >
void erase (C &container, typename impl::hash_container_traits< C >::value_type const &t)
 
template<class C , class F , typename std::enable_if< impl::sequence_container_traits< C >::exist >::type *& = enabler>
void erase_if (C &container, F const &remove_pred)
 
template<class RC , class C >
auto copy (C &&src) -> RC
 別の種類のコンテナに要素をコピーする More...
 
template<class B >
bool And (B &&cond)
 
template<class B1 , class... Bs>
bool And (B1 &&cond, Bs &&...conds)
 可変長 and More...
 
template<class B >
bool Or (B &&cond)
 
template<class B1 , class... Bs>
bool Or (B1 &&cond, Bs &&...conds)
 可変長 or More...
 
template<class B1 , class B2 >
bool Xor (B1 &&a, B2 &&b)
 xor More...
 
template<class B1 , class B2 >
bool Consistency (B1 &&a, B2 &&b)
 AとBの真偽一致でtrueを返す (⇔ !xor) More...
 
template<class T >
auto min (T v) -> T
 
template<class T1 , class T2 >
auto min (T1 v1, T2 v2)
 
template<class T , class... Ts>
auto min (T v, Ts...vs)
 可変長 min More...
 
template<class T >
auto max (T v) -> T
 
template<class T1 , class T2 >
auto max (T1 v1, T2 v2)
 
template<class T , class... Ts>
auto max (T v, Ts...vs)
 可変長 max More...
 
template<class T >
constexpr bool is_number (T x)
 値が非数(NaN)でないかを確認 More...
 
template<class T >
constexpr bool is_finite_number (T x)
 値が非数(NaN)でなく、かつ無限大(Inf)でないかを確認 More...
 
template<class T >
T abs_delta (T v1, T v2)
 
template<class T1 , class T2 >
auto abs_delta (T1 v1, T2 v2) -> decltype(v1< v2?v2-v1:v1-v2)
 2変数の差の絶対値を返す More...
 
template<class T1 , class T2 , typename std::enable_if<!(impl::is_string< T1 >::value||impl::is_string< T2 >::value)>::type *& = enabler>
bool equal (T1 &&v1, T2 &&v2)
 数値の簡易等値比較（厳密な計算でない場合の使用を想定） More...
 
template<class S1 , class S2 , typename std::enable_if<(impl::is_string< S1 >::value &&impl::is_string< S2 >::value)>::type *& = enabler>
bool equal (S1 &&v1, S2 &&v2)
 文字列の等値比較 More...
 
template<class T1 , class T2 >
bool equal_tolerant (T1 v1, T2 v2, typename std::common_type< T1, T2 >::type margin)
 指定範囲内の誤差を許した等値比較 More...
 
template<class T , class U >
constexpr bool check_range (T const &val, U const &min, U const &max)
 値の範囲チェック More...
 
template<class T , class U >
bool modify_range (T &val, U const &min, U const &max)
 値を範囲内に自動修正 More...
 
template<class T1 , class T2 >
constexpr bool greater (T1 v1, T2 v2)
 
template<class T1 , class T2 >
constexpr bool less (T1 v1, T2 v2)
 
template<class T , class R = typename sig::impl::remove_const_reference<T>::type>
Maybe< R > Just (T &&v)
 値コンストラクタ More...
 
template<class T >
Maybe< T > Just (T const &v)
 
template<class T = void>
auto Nothing () -> typename impl::SameIf< T, void, typename boost::none_t, Maybe< T >>::type
 値コンストラクタ More...
 
template<class T >
auto Nothing (T const &dummy) -> Maybe< T >
 値コンストラクタ More...
 
template<class T >
bool isJust (Maybe< T > const &m)
 Justであるか調べる関数．Maybe a -> Bool. More...
 
constexpr bool isJust (boost::none_t m)
 
template<class T >
bool isNothing (Maybe< T > const &m)
 Nothingであるか調べる関数．Maybe a -> Bool. More...
 
constexpr bool isNothing (boost::none_t m)
 
template<class T >
T & fromJust (Maybe< T > &m)
 Justから値を取り出す関数．Maybe a -> a. More...
 
template<class T >
T const & fromJust (Maybe< T > const &m)
 
template<class T >
T && fromJust (Maybe< T > &&m)
 
template<class T >
T & operator* (Maybe< T > &m)
 fromJust演算子 More...
 
template<class T >
T const & operator* (Maybe< T > const &m)
 
template<class T >
T && operator* (Maybe< T > &&m)
 
template<class T >
T & fromMaybe (T &def, Maybe< T > &m)
 Maybeから値を取り出す関数．もしNothingなら引数のデフォルト値を返す．a -> Maybe a -> a. More...
 
template<class T >
T const & fromMaybe (T const &def, Maybe< T > const &m)
 
template<class T >
T && fromMaybe (T &&def, Maybe< T > &&m)
 
template<class T >
T && fromMaybe (T &&def, boost::none_t m)
 
template<class F , class C >
auto mapMaybe (F const &f, C const &list) -> typename impl::container_traits< C >::template rebind< typename std::remove_reference< decltype(*(impl::eval(f, std::declval< typename impl::container_traits< C >::value_type >())))>::type >
 Maybeを返す関数を指定するfilter関数．(a -> Maybe b) -> [a] -> [b]. More...
 
template<class T , class F >
auto operator>>= (Maybe< T > const &m, F const &f) -> decltype(impl::eval(f, std::declval< T >()))
 Haskell風のbind演算子. Maybe m => m a -> (a -> m b) -> m b. More...
 
template<class F , class T >
auto operator<<= (F const &f, Maybe< T > const &m) -> decltype(impl::eval(f, std::declval< T >()))
 C++に合わせたbind演算子. Maybe m => (a -> m b) -> m a -> m b. More...
 
template<class T1 , class T2 >
auto operator<<= (Maybe< T1 > &m, T2 const &v) -> Maybe< T1 > &
 Maybeオブジェクトへの再代入を行う演算子 More...
 
template<class C , class CR = typename impl::remove_const_reference<C>::type, class T = typename impl::container_traits<CR>::value_type>
auto remove_duplicates (C &container)
 コンテナの要素から重複した値を削除 More...
 
template<class C >
bool remove_one (C &container, typename boost::call_traits< typename impl::container_traits< C >::value_type >::param_type remove)
 コンテナから指定した値を1つ削除 More...
 
template<class Pred , class C >
bool remove_one_if (C &container, Pred remove_pred)
 コンテナから述語条件を満たす値を1つ削除 More...
 
template<class C >
bool remove_all (C &container, typename boost::call_traits< typename impl::container_traits< C >::value_type >::param_type remove)
 コンテナから指定した値を全削除 More...
 
template<class Pred , class C >
bool remove_all_if (C &container, Pred remove_pred)
 コンテナから述語条件を満たす値を全削除 More...
 
template<class C >
void shuffle (C &container)
 コンテナの要素をシャッフル More...
 
template<class... Cs>
void shuffle (Cs &...containers)
 複数のコンテナの同じインデックスの要素を対応させながらシャッフル More...
 
template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class T = typename impl::sequence_container_traits<CR>::value_type, typename std::enable_if< impl::has_random_access_iter< CR >::value >::type *& = enabler>
auto sort (C &container, F &&binary_op) -> decltype(impl::eval(std::forward< F >(binary_op), std::declval< T >(), std::declval< T >()), void())
 標準ソート関数のラッパ More...
 
template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class T = typename impl::static_container_traits<CR>::value_type, class D = void, typename std::enable_if< impl::has_random_access_iter< CR >::value >::type *& = enabler>
auto sort (C &container, F &&binary_op) -> decltype(impl::eval(std::forward< F >(binary_op), std::declval< T >(), std::declval< T >()), void())
 
template<class C , class F , class T = typename impl::container_traits<typename impl::remove_const_reference<C>::type>::value_type>
auto sort_with_index (C &&container, F &&binary_op)
 ソート前の位置を保持してソート More...
 
auto wstr_to_str (std::wstring const &src) -> std::string
 ワイド文字 -> マルチバイト文字 More...
 
template<class C , class R = typename impl::container_traits<C>::template rebind<std::string>, typename std::enable_if< std::is_same< typename impl::container_traits< C >::value_type, std::wstring >::value >::type *& = enabler>
auto wstr_to_str (C const &src) -> R
 ワイド文字 -> マルチバイト文字 More...
 
auto str_to_wstr (std::string const &src) -> std::wstring
 マルチバイト文字 -> ワイド文字 More...
 
template<class C , class R = typename impl::container_traits<C>::template rebind<std::wstring>, typename std::enable_if< std::is_same< typename impl::container_traits< C >::value_type, std::string >::value >::type *& = enabler>
auto str_to_wstr (C const &src) -> R
 マルチバイト文字 -> ワイド文字 More...
 
auto utf8_to_utf16 (std::string const &src) -> std::u16string
 UTF-8 -> UTF-16. More...
 
auto utf16_to_utf8 (std::u16string const &src) -> std::string
 UTF-16 -> UTF-8. More...
 
auto utf8_to_utf32 (std::string const &src) -> std::u32string
 UTF-8 -> UTF-32. More...
 
auto utf32_to_utf8 (std::u32string const &src) -> std::string
 UTF-32 -> UTF-8. More...
 
auto sjis_to_utf16 (std::string const &src) -> std::u16string
 ShiftJIS -> UTF-16. More...
 
auto utf16_to_sjis (std::u16string const &src) -> std::string
 UTF-16 -> ShiftJIS. More...
 
auto sjis_to_utf8 (std::string const &src) -> std::string
 ShiftJIS -> UTF-8. More...
 
auto utf8_to_sjis (std::string const &src) -> std::string
 UTF-8 -> ShiftJIS. More...
 
template<template< class T_, class=std::allocator< T_ >> class CSeq = std::vector, class S = std::string, class TS = impl::string_t<S>>
auto split (S const &src, impl::string_t< S > const &delimiter) -> CSeq< TS >
 文字列(src)をある文字列(delimiter)を目印に分割する More...
 
template<template< class T_, class=std::allocator< T_ >> class CSeq = std::vector>
auto split (char const *const src, char const *const delimiter) -> CSeq< std::string >
 
template<template< class T_, class=std::allocator< T_ >> class CSeq = std::vector>
auto split (wchar_t const *const src, wchar_t const *const delimiter) -> CSeq< std::wstring >
 
template<class C , class CR = typename impl::remove_const_reference<C>::type, class S = typename impl::SStreamSelector<typename impl::container_traits<CR>::value_type>::string>
auto cat (C &&container, typename sig::impl::identity< S >::type const &delimiter, std::locale osstream_locale=std::locale("")) -> S
 コンテナ中の各文字列や数値を結合 More...
 
template<class T , class S = typename impl::SStreamSelector<T>::string>
auto cat (std::initializer_list< T > container, typename sig::impl::identity< S >::type const &delimiter, std::locale osstream_locale=std::locale("")) -> S
 
auto escape_regex (std::string const &expression) -> std::string
 与えられた文字中に含まれる、正規表現の特殊文字をエスケープする More...
 
auto escape_regex (std::wstring const &expression) -> std::wstring
 
template<class S >
auto make_regex (S const &expression) -> typename impl::Str2RegexSelector< impl::string_t< S >>::regex
 エスケープ処理を行い、regexオブジェクトを返す More...
 
template<class S , class TS = impl::string_t<S>>
auto regex_search (S &&src, typename impl::Str2RegexSelector< TS >::regex const &expression) -> Maybe< std::vector< std::vector< TS >>>
 std::regex_search のラッパ関数 More...
 
template<class C , typename std::enable_if< container_traits< C >::exist >::type *& = enabler>
void save_line (C const &src, typename impl::FStreamSelector< typename container_traits< C >::value_type >::ofstream &ofs)
 
template<class C , typename std::enable_if< container_traits< C >::exist &&!container_traits< typename container_traits< C >::value_type >::exist >::type *& = enabler>
void save_num (C const &src, FilepassString const &file_pass, WriteMode mode=WriteMode::overwrite, std::string delimiter="\n")
 
template<class CC , typename std::enable_if< container_traits< typename container_traits< CC >::value_type >::exist >::type *& = enabler>
void save_num (CC const &src, FilepassString const &file_pass, WriteMode mode=WriteMode::overwrite, std::string delimiter1="\n", std::string delimiter2="\n\n")
 
template<class C , class R = typename container_traits<C>::value_type>
bool read_line (C &empty_dest, IfsSelector< R > &ifs, std::function< R(typename impl::SameIf< R, std::string, std::string, std::wstring >::type) > const &conv=nullptr)
 
template<class C , class R = typename container_traits<C>::value_type>
bool read_line (C &empty_dest, FilepassString const &file_pass, std::function< R(typename impl::SameIf< R, std::string, std::string, std::wstring >::type)> const &conv=nullptr)
 
template<class R , class C = std::vector<R>>
auto read_line (IfsSelector< R > &ifs) -> Just< C >
 
template<class R , class C = std::vector<R>>
auto read_line (FilepassString const &file_pass) -> Just< C >
 
template<class R , class C = std::vector<R>>
auto read_line (FilepassStringC file_pass) -> Just< C >
 
template<class C , class RT = typename container_traits<C>::value_type, typename std::enable_if<!container_traits< typename container_traits< C >::value_type >::exist >::type *& = enabler>
bool read_num (C &empty_dest, FilepassString const &file_pass, std::string delimiter="\n")
 
template<class CC , class RC = typename container_traits<CC>::value_type, class RT = typename container_traits<RC>::value_type>
bool read_num (CC &empty_dest, FilepassString const &file_pass, std::string delimiter1="\n", std::string delimiter2="\n\n")
 
template<class C , typename std::enable_if< container_traits< C >::exist &&!container_traits< typename container_traits< C >::value_type >::exist >::type *& = enabler>
auto read_num (FilepassString const &file_pass, std::string delimiter="\n") -> Just< C >
 
void Print (std::string const &text, char const *const delimiter="\n")
 
void Print (std::wstring const &text, wchar_t const *const delimiter=L"\n")
 
template<class T , template< class...> class Container, typename std::enable_if<!std::is_same< T, std::wstring >::value >::type *& = enabler>
void Print (Container< T > const &container, char const *const delimiter="\n")
 
template<template< class...> class Container>
void Print (Container< std::wstring > const &container, wchar_t const *const delimiter=L"\n")
 
template<class CC1 , class CC2 >
auto GaleShapley (CC1 const &men_vec, CC2 const &women_vec)
 
template<class C = std::vector<int>>
C make_unique_numbers (uint n, int min, int max, bool debug)
 重複の無い一様分布の整数乱数を生成 More...
 
template<class IFS_CHAR , class C , class R = typename impl::container_traits<C>::value_type>
bool load_line (C &empty_dest, std::basic_ifstream< IFS_CHAR > &ifs)
 ファイルから1行ずつ読み込む（ifstreamを指定） More...
 
template<class C , class R = typename impl::container_traits<C>::value_type>
bool load_line (C &empty_dest, FilepassString const &file_pass)
 ファイルから1行ずつ読み込む（ファイル名を指定） More...
 
template<class ISTR = std::string, class C = std::vector<ISTR>>
auto load_line (FilepassString const &file_pass) -> Maybe< C >
 ファイルから1行ずつ読み込み、結果を返す（ファイル名を指定） More...
 
template<class ISTR = std::string, class R = ISTR, class C = std::vector<R>>
auto load_line (FilepassStringC file_pass) -> Maybe< C >
 
template<class IFS_CHAR , class F , class C , class R = typename impl::container_traits<C>::value_type>
bool load_line (C &empty_dest, std::basic_ifstream< IFS_CHAR > &ifs, F const &conv)
 ファイルから1行ずつ読み込み、同時に変換処理を行う（ifstreamを指定） More...
 
template<class ISTR = std::string, class F , class C , class R = typename impl::container_traits<C>::value_type>
bool load_line (C &empty_dest, FilepassString const &file_pass, F const &conv)
 ファイルから1行ずつ読み込み、同時に変換処理を行う（ファイル名を指定） More...
 
template<class C , class RT = typename impl::container_traits<C>::value_type, typename std::enable_if<!impl::container_traits< typename impl::container_traits< C >::value_type >::exist >::type *& = enabler>
bool load_num (C &empty_dest, FilepassString const &file_pass, std::string delimiter="\n")
 数値列を読み込む More...
 
template<class R , class C = std::vector<R>, typename std::enable_if< impl::container_traits< C >::exist &&!impl::container_traits< typename impl::container_traits< C >::value_type >::exist >::type *& = enabler>
auto load_num (FilepassString const &file_pass, std::string delimiter="\n") -> Maybe< C >
 数値列を読み込み、結果を返す More...
 
template<class CC , class RC = typename impl::container_traits<CC>::value_type, class RT = typename impl::container_traits<RC>::value_type>
bool load_num2d (CC &empty_dest, FilepassString const &file_pass, std::string delimiter)
 2次元配列の数値(ex:行列)を読み込む More...
 
template<class R , class CC = std::vector<std::vector<R>>, typename std::enable_if< impl::container_traits< typename impl::container_traits< CC >::value_type >::exist >::type *& = enabler>
auto load_num2d (FilepassString const &file_pass, std::string delimiter) -> Maybe< CC >
 2次元配列の数値(ex:行列)を読み込む More...
 
template<class T , typename std::enable_if<!impl::container_traits< T >::exist >::type *& = enabler>
void save_line (T src, typename impl::FStreamSelector< T >::ofstream &ofs)
 ファイルへ1行ずつ保存 More...
 
template<class C , typename std::enable_if< impl::container_traits< C >::exist >::type *& = enabler>
void save_line (C const &src, typename impl::FStreamSelector< typename impl::container_traits< C >::value_type >::ofstream &ofs)
 ファイルへ1行ずつまとめて保存 More...
 
template<class T , typename std::enable_if<!impl::container_traits< T >::exist >::type *& = enabler>
void save_line (T src, FilepassString const &file_pass, WriteMode open_mode=WriteMode::overwrite)
 ファイルへ1行ずつ保存 More...
 
template<class C , typename std::enable_if< impl::container_traits< C >::exist >::type *& = enabler>
void save_line (C const &src, FilepassString const &file_pass, WriteMode open_mode=WriteMode::overwrite)
 ファイルへ1行ずつまとめて保存 More...
 
template<class C , typename std::enable_if< impl::container_traits< C >::exist &&!impl::container_traits< typename impl::container_traits< C >::value_type >::exist >::type *& = enabler>
void save_num (C const &src, FilepassString const &file_pass, std::string delimiter, WriteMode open_mode=WriteMode::overwrite)
 数値列(ex:ベクトル)の保存 More...
 
template<class CC , typename std::enable_if< impl::container_traits< typename impl::container_traits< CC >::value_type >::exist >::type *& = enabler>
void save_num (CC const &src, FilepassString const &file_pass, std::string delimiter, WriteMode open_mode=WriteMode::overwrite)
 2次元配列の数値(ex:行列)を保存 More...
 

Variables

const BinaryDistance binary_distance
 バイナリ距離を求める関数（関数オブジェクト） More...
 
const CanberraDistance canberra_distance
 キャンベラ距離を求める関数（関数オブジェクト） More...
 
const CosineSimilarity cosine_similarity
 コサイン類似度を求める関数（関数オブジェクト） More...
 
const JS_Divergence js_divergence
 JS情報量を求める関数（関数オブジェクト） More...
 
const KL_Divergence kl_divergence
 KL情報量を求める関数（関数オブジェクト） More...
 
const ManhattanDistance manhattan_distance
 マンハッタン距離を求める関数（関数オブジェクト） More...
 
const EuclideanDistance euclidean_distance
 ユークリッド距離を求める関数（関数オブジェクト） More...
 
const Norm< 1 > norm_L1
 L1ノルムを求める関数（関数オブジェクト） More...
 
const Norm< 2 > norm_L2
 L2ノルムを求める関数（関数オブジェクト） More...
 
const MaxNorm norm_max
 最大ノルムを求める関数（関数オブジェクト） More...
 
void * enabler
 
const AbsoluteError absolute_error
 
const RelativeError relative_error
 

Typedef Documentation

using sig::EuclideanDistance = typedef MinkowskiDistance<2>

Definition at line 65 of file minkowski_distance.hpp.

template<class R >
using sig::IfsSelector = typedef typename impl::SameIf<R, std::string, std::ifstream, std::wifstream>::type

Definition at line 295 of file file_tmp(save,read num).hpp.

using sig::ManhattanDistance = typedef MinkowskiDistance<1>

Definition at line 45 of file minkowski_distance.hpp.

template<class T >
using sig::matrix_u = typedef boost::numeric::ublas::matrix<T>

Definition at line 28 of file ublas.hpp.

template<class T >
using sig::Maybe = typedef boost::optional<T>

Definition at line 45 of file maybe.hpp.

template<class T >
using sig::vector_u = typedef boost::numeric::ublas::vector<T>

Definition at line 49 of file ublas.hpp.

Enumeration Type Documentation

enum sig::WriteMode
strong

SaveLine, SaveNum の保存に関する設定

Enumerator
overwrite 

上書き

append 

末尾追記

overwrite 
append 

Definition at line 24 of file save.hpp.

enum sig::WriteMode
strong
Enumerator
overwrite 

上書き

append 

末尾追記

overwrite 
append 

Definition at line 174 of file file_tmp(save,read num).hpp.

Function Documentation

template<class T >
T sig::abs_delta ( T  v1,
T  v2 
)

Definition at line 235 of file helper_modules.hpp.

template<class T1 , class T2 >
auto sig::abs_delta ( T1  v1,
T2  v2 
) -> decltype(v1 < v2 ? v2 - v1 : v1 - v2)

2変数の差の絶対値を返す

Precondition
operator< , operator-
static_assert( abs_delta(1, 3) == 2, "");
static_assert( abs_delta(-2, -1) == 1, "");
static_assert( abs_delta(3.0, 1.5) == 1.5, "");
static_assert( abs_delta(3, 1.5) == 1.5, "");

Definition at line 255 of file helper_modules.hpp.

template<class B >
bool sig::And ( B &&  cond)

Definition at line 24 of file helper_modules.hpp.

template<class B1 , class... Bs>
bool sig::And ( B1 &&  cond,
Bs &&...  conds 
)

可変長 and

Parameters
cond,condsbool変数 または operator boolが定義されたオブジェクト
Returns
全引数に対してandを取った結果
static_assert(And(true, true, true, true), "");
static_assert(!And(false, true, false, true, false), "");

Definition at line 43 of file helper_modules.hpp.

template<class C >
double sig::average ( C const &  data)

平均

Parameters
data平均を求めたい値集合（対応コンテナ ）
Returns
計算結果
std::vector<int> vec{1,2,3,4};
double ave = average(vec); // 2.5

Definition at line 223 of file basic_statistics.hpp.

template<class OP , class T1 , class T2 , typename std::enable_if< (!impl::container_traits< typename impl::remove_const_reference< T1 >::type >::exist)&&(!impl::container_traits< typename impl::remove_const_reference< T2 >::type >::exist) >::type *& = enabler>
auto sig::binary_operation ( OP &&  func,
T1 &&  v1,
T2 &&  v2 
) -> typename impl::remove_const_reference< decltype(impl::eval(std::forward<OP>(func), std::forward<T1>(v1), std::forward<T2>(v2)))>::type

二項演算 (scalar and scalar)

Parameters
func二項演算関数
v1引数1
v2引数2
Returns
演算結果

Definition at line 33 of file binary_operation.hpp.

template<class OP , class C1 , class C2 , class CR1 = typename impl::remove_const_reference<C1>::type, class CR2 = typename impl::remove_const_reference<C2>::type, class AT1 = typename impl::forward_element<C1>::type, class AT2 = typename impl::forward_element<C2>::type, typename std::enable_if< impl::container_traits< CR1 >::exist &&impl::container_traits< CR2 >::exist >::type *& = enabler>
auto sig::binary_operation ( OP &&  func,
C1 &&  c1,
C2 &&  c2 
) -> typename impl::container_traits<CR1>::template rebind< typename impl::remove_const_reference<decltype(impl::eval( std::forward<OP>(func), std::declval<AT1>(), std::declval<AT2>() ))>::type >

二項演算 (element-wise: container and container)

Definition at line 49 of file binary_operation.hpp.

template<class OP , class C , class T , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type, typename std::enable_if< impl::container_traits< CR >::exist &&(!impl::container_traits< typename impl::remove_const_reference< T >::type >::exist) >::type *& = enabler>
auto sig::binary_operation ( OP &&  func,
C &&  c,
T &&  v 
) -> typename impl::container_traits<CR>::template rebind< typename impl::remove_const_reference<decltype(impl::eval( std::forward<OP>(func), std::declval<ET>(), v ))>::type >

二項演算 (element-wise: container and scalar)

Definition at line 76 of file binary_operation.hpp.

template<class OP , class T , class C , class ET = typename impl::forward_element<C>::type, class CR = typename impl::remove_const_reference<C>::type, typename std::enable_if< (!impl::container_traits< typename impl::remove_const_reference< T >::type >::exist)&&impl::container_traits< CR >::exist >::type *& = enabler>
auto sig::binary_operation ( OP &&  func,
T &&  v,
C &&  c 
) -> typename impl::container_traits<CR>::template rebind< typename impl::remove_const_reference<decltype(impl::eval( std::forward<OP>(func), v, std::declval<ET>() ))>::type >

二項演算 (element-wise: scalar and container)

Definition at line 104 of file binary_operation.hpp.

template<class C , class CR = typename impl::remove_const_reference<C>::type, class S = typename impl::SStreamSelector<typename impl::container_traits<CR>::value_type>::string>
auto sig::cat ( C &&  container,
typename sig::impl::identity< S >::type const &  delimiter,
std::locale  osstream_locale = std::locale("") 
) -> S

コンテナ中の各文字列や数値を結合

conatiner中の要素が数値の場合、ostringstreamで出力される文字列に変換される

Parameters
container文字列か数値が格納されたコンテナ（対応コンテナ ）
delimiter結合する文字列間に挿入される文字列
osstream_locale[option] 出力に影響するロケール
Returns
結合した文字列
auto cat1 = cat(std::vector<std::string>{"eins", "zwei", "drei"}, "");
auto cat2 = cat(std::list<std::wstring>{L"eins", L"zwei", L"drei"}, L",");
assert(cat1 == "einszweidrei");
assert(cat2 == L"eins,zwei,drei");

Definition at line 155 of file manipulate.hpp.

template<class T , class S = typename impl::SStreamSelector<T>::string>
auto sig::cat ( std::initializer_list< T >  container,
typename sig::impl::identity< S >::type const &  delimiter,
std::locale  osstream_locale = std::locale("") 
) -> S

containerがinitializer_listの場合

See also
cat(C const& container, S const& delimiter, std::locale osstream_locale)

Definition at line 177 of file manipulate.hpp.

template<class T , class U >
constexpr bool sig::check_range ( T const &  val,
U const &  min,
U const &  max 
)

値の範囲チェック

min ≦ val ≦ max であるか確認

Parameters
val確認したい値
min範囲の下限
max範囲の上限
Returns
valが範囲内に収まっているか
int cr = 5;
assert( check_range(cr, 0, 10));
assert(!check_range(cr, 0, 3));
assert(cr == 5);

Definition at line 347 of file helper_modules.hpp.

void sig::clear_file ( FilepassString const &  file_pass)
inline

ファイル内容の初期化

Parameters
file_pass初期化したいファイルのパス
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./src"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
clear_file(fpass);

Definition at line 43 of file save.hpp.

template<class F , class C1 , class C2 , typename std::enable_if< impl::container_traits< C1 >::exist &&impl::container_traits< C2 >::exist >::type *& = enabler>
void sig::compound_assignment ( F &&  assign_op,
C1 &  dest,
C2 const &  src 
)

コンテナへの代入演算 (element-wise: container and container)

indexが対応するsrcとdestの各要素に関数を適用し、その結果をdestコンテナに格納する

Parameters
assign_opsrcとdestの各要素を引数に取る関数
dest代入先のコンテナ（対応コンテナ ）
src任意のコンテナ（対応コンテナ ）
const array<int, 4> data0{ 1, 2, 3, 4 }; // sig::array
std::list<double> data1{ 1.1, -3.3, 5.5 };
compound_assignment([](double& v1, int v2){ v1 -= v2; }, data1, data0);
data1; // { 0.1, -5.3, 2.5 }

Definition at line 39 of file assign_operation.hpp.

template<class F , class C , class T , typename std::enable_if< impl::container_traits< C >::exist &&!impl::container_traits< T >::exist >::type *& = enabler>
void sig::compound_assignment ( F &&  assign_op,
C &  dest,
T  src 
)

コンテナへの代入演算 (element-wise: container and scalar)

srcとdestの各要素に関数を適用し、その結果をdestコンテナに格納する

Parameters
assign_opsrcの各要素を処理する関数
dest代入先のコンテナ（対応コンテナ ）
src任意の値
std::vector<std::string> data{ "ein", "zwei", "drei" };
compound_assignment([](std::string& str, std::string add){ str += add; }, data, std::string("-hander"));
data; // { "ein-hander", "zwei-hander", "drei-hander" }

Definition at line 66 of file assign_operation.hpp.

template<class B1 , class B2 >
bool sig::Consistency ( B1 &&  a,
B2 &&  b 
)

AとBの真偽一致でtrueを返す (⇔ !xor)

Parameters
cond,condsbool変数 または operator boolが定義されたオブジェクト
Returns
!xorの結果
static_assert(Consistency(true, true), "");
static_assert(!Consistency(true, false), "");
static_assert(!Consistency(false, true), "");
static_assert(Consistency(false, false), "");

Definition at line 113 of file helper_modules.hpp.

template<class RC , class C >
auto sig::copy ( C &&  src) -> RC

別の種類のコンテナに要素をコピーする

Template Parameters
RCコピー先のコンテナ型（対応コンテナ ）
Parameters
srcコピー元のコンテナ（対応コンテナ ）
Returns
コピーされたコンテナ

Definition at line 269 of file container_helper.hpp.

template<class T1 , class T2 >
auto sig::div ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(div_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 151 of file binary_operation.hpp.

template<class F1 , class F2 , class T , class... Cs>
auto sig::dotProduct ( F1 &&  fold_func,
F2 &&  oper_func,
T &&  init,
Cs &&...  lists 
)

可変長個のコンテナに対して関数適用して結果を集約する関数

(a -> a -> a) -> (b -> c -> ... -> a) -> a0 -> [b] -> [c] -> ... -> a
a0はaに暗黙的に型変換可能
listsのいずれかの末尾に到達するまで集約の計算が行われる

Parameters
fold_funcoper_funcで計算した結果を集約する関数 (a -> a -> a)
oper_func各コンテナの要素を引数に取る関数 (b -> c -> ... -> a)
init初期値 a0
lists...データが格納されたコンテナ [b] [c] ...（対応コンテナ ）
Returns
処理結果 a
const array<int, 5> data1{ 1, 2, 3, 4, 5 }; // sig::array
const std::vector<int> data2{ 1, -3, 5, 2, 10 };
const std::list<int> data3{ 1, -3, 5, 2 };
double dp = dotProduct(
[](double sum, double a){ return sum + a; },
[](int b, int c, int d, double e){ return std::pow(b*b + c*c + d*d + e*e, 0.25); },
0,
data1, data2, data3, array<double, 4>{ 1.1, 2.2, 3.3, 4.4 }
);

Definition at line 111 of file fold.hpp.

template<class C , class CR = typename impl::remove_const_reference<C>::type>
auto sig::drop ( uint  n,
C &&  list 
) -> CR

コンテナの先頭からn個を削除したコンテナを返す

uint -> [a] -> [a]

Parameters
n先頭から順に削除する要素の個数
listソースとなるコンテナ（対応コンテナ ）
Returns
結果のコンテナ（listと同じ種類）
const array<int, 4> data1{ 1, 2, 3, 4 }; // sig::array
std::vector<int> data2{ 1, -3, 5, 2, 10 };
auto t1 = drop(2, data1); // array<int, 4>{ 3, 4 }
auto t2 = drop(3, data2); // std::vector<int> data2{ 2, 10 }

Definition at line 256 of file list_deal.hpp.

template<class T1 , class T2 , typename std::enable_if<!(impl::is_string< T1 >::value||impl::is_string< T2 >::value)>::type *& = enabler>
bool sig::equal ( T1 &&  v1,
T2 &&  v2 
)

数値の簡易等値比較（厳密な計算でない場合の使用を想定）

浮動小数点型の誤差をある程度許容． デフォルトでは 10^(-12) 未満の誤差を無視

assert( equal(1, 1));
assert( equal(1, 1u));
assert( equal(1u, 1));
assert( equal(1u, 1u));
assert( equal(1, 1.0));
assert( equal(1.0, 1));
assert( equal('a', 'a'));
int ct = 0;
for (double f = 0.0; !equal(f, 1); f += 0.01, ++ct){
if (ct >= 100) assert(false);
}

Definition at line 282 of file helper_modules.hpp.

template<class S1 , class S2 , typename std::enable_if<(impl::is_string< S1 >::value &&impl::is_string< S2 >::value)>::type *& = enabler>
bool sig::equal ( S1 &&  v1,
S2 &&  v2 
)

文字列の等値比較

assert( equal("tes", "tes"));
assert( equal(L"tes", L"tes"));
assert( equal("tes", std::string("tes")));
assert( equal(std::string("tes"), "tes"));
assert( equal(L"tes", std::wstring(L"tes")));
assert( equal(std::wstring(L"tes"), L"tes"));

Definition at line 305 of file helper_modules.hpp.

template<class T1 , class T2 >
bool sig::equal_tolerant ( T1  v1,
T2  v2,
typename std::common_type< T1, T2 >::type  margin 
)

指定範囲内の誤差を許した等値比較

Parameters
v1,v2等値比較したい値
margin許容する誤差
Returns
誤差を許容した等値比較の結果
assert( equal_tolerant(0.001, 0.002, 0.001));
assert(!equal_tolerant(0.001, 0.003, 0.001));

Definition at line 324 of file helper_modules.hpp.

template<class C >
void sig::erase ( C &  container,
typename impl::sequence_container_traits< C >::value_type const &  t 
)

Definition at line 213 of file container_helper.hpp.

template<class C >
void sig::erase ( C &  container,
typename impl::associative_container_traits< C >::value_type const &  t 
)

Definition at line 219 of file container_helper.hpp.

template<class C >
void sig::erase ( C &  container,
typename impl::hash_container_traits< C >::value_type const &  t 
)

Definition at line 225 of file container_helper.hpp.

template<class C , class F , typename std::enable_if< impl::sequence_container_traits< C >::exist >::type *& = enabler>
void sig::erase_if ( C &  container,
F const &  remove_pred 
)

Definition at line 232 of file container_helper.hpp.

auto sig::escape_regex ( std::string const &  expression) -> std::string
inline

与えられた文字中に含まれる、正規表現の特殊文字をエスケープする

auto raw1 = "? or () must be escaped";
auto escaped1 = escape_regex(raw1);
auto escaped2 = escape_regex(L"?とか()はエスケープすべき文字");
auto test1 = R"(\? or \(\) must be escaped)";
assert(escaped1 == test1);
auto test2 = LR"(\?とか\(\)はエスケープすべき文字)";
assert(escaped2 == test2);

Definition at line 88 of file regex.hpp.

auto sig::escape_regex ( std::wstring const &  expression) -> std::wstring
inline
See also
escape_regex(std::string const& expression)

Definition at line 98 of file regex.hpp.

template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type>
auto sig::filter ( F &&  pred,
C &&  list 
)

コンテナから指定条件を満たす要素を抽出する

(a -> Bool) -> [a] -> [a]

Parameters
pred条件判定を行う述語関数 (a -> Bool)
listデータが格納されたコンテナ [a]（対応コンテナ ）
Returns
処理結果のコンテナ [a]（コンテナはlistと同じ種類）
const std::unordered_set<double> data2{ 0, 1.1, -2.2, 3.3 };
array<std::string, 3> data2{ "a", "bbb", "cc" }; // sig::array
auto fl1 = filter([](int v){ return v % 2; }, data1);
auto fl2 = filter([](std::string const& v){ return v.length() < 3; }, std::move(data2));
fl1; // std::unordered_set<double>{ -2.2 }
fl2; // array<std::string, 3>{ "a", "cc" } // array[2]は未使用
assert(data2[0].empty() && data2[2].empty() && (!data2[1].empty()) );

Definition at line 44 of file filter.hpp.

template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type>
auto sig::filter ( F &&  pred,
int  init,
C &&  list 
)

コンテナから指定条件を満たす要素を抽出する(反復回数を表すindexが利用できる)

(int -> a -> Bool) -> int -> [a] -> [a]

Parameters
pred条件判定を行う述語関数 (int -> a -> Bool)
initindexの初期値 int
listデータが格納されたコンテナ [a]（対応コンテナ ）
Returns
処理結果のコンテナ [a]（コンテナはlistと同じ種類）
const array<double, 3> data{ 1.1, 1.5, 4 };
auto filt3 = filter([](int i, double v){ return v / i < 1; }, 1, data);
data; // { 1.5 }

Definition at line 75 of file filter.hpp.

template<class F , class T , class C >
auto sig::foldl ( F &&  func,
T &&  init,
C &&  list 
)

コンテナの先頭からたたみ込み

(a -> b -> a) -> a0 -> [b] -> a
a0はaに暗黙的に型変換可能

Parameters
func関数 (a -> b -> a)
init初期値 a0
listデータが格納されたコンテナ [b]（対応コンテナ ）
Returns
処理結果 a
See also
foldr(F const& func, T init, C const& list)
const std::set<double> data1{ -2.2, 0 , 1.1, 3.3 };
const array<int, 4> data2{ 1, -3, 5, 4 }; // sig::array
double r1 = foldl(std::plus<double>(), 0, data1);
double r2 = foldl([](double sum, int v){ return sum + v % 2; }, 0, data2);
r1; // 2.2
r2; // 1

Definition at line 43 of file fold.hpp.

template<class F , class T , class C >
auto sig::foldr ( F &&  func,
T &&  init,
C &&  list 
)

コンテナの末尾からたたみ込み

(a -> b -> b) -> b0 -> [a] -> b
b0はbに暗黙的に型変換可能

Parameters
func関数 (a -> b -> a)
init初期値 b0
listデータが格納されたコンテナ [a]（対応コンテナ ）
Returns
処理結果 b
See also
foldl(F const& func, T init, C const& list)
int fl = foldl(std::minus<int>(), 1, array<int, 3>{ 2, 3, 4 }); // ((1-2)-3)-4
int fr = foldr(std::minus<int>(), 4, array<int, 3>{ 1, 2, 3 }); // 1-(2-(3-4))
assert(fl0 == ((1-2)-3)-4);
assert(fr0 == 1-(2-(3-4)));

Definition at line 74 of file fold.hpp.

template<class F , class M >
void sig::for_diagonal ( F &&  func,
M &  mat 
)

行列の対角要素の対して、代入演算を行う関数を適用する

Definition at line 345 of file ublas.hpp.

template<class F , class... Cs>
void sig::for_each ( F &&  func,
Cs &&...  containers 
)

複数コンテナを反復処理

先頭の要素から順番に関数を適用し、いずれかのコンテナの末尾に到達するまで繰り返す．
適用する関数オブジェクトの引数を参照(&)にすることで、値の変更が可能

Parameters
func関数オブジェクト(引数の順番は渡すcontainersの順番に対応)
containers処理対象のコンテナ（対応コンテナ ）
See also
for_each(F const& func, int init, Cs&&... containers)
array<double, 4> data1{ 1.1, 2.2, 3.3, 4.4 }; // sig::array
const std::list<int> data2{ 1, -3, 5 };
const std::multiset<std::string> data3{ "a", "bb", "ccc" };
for_each([](double& a, int b, std::string const& s)
{
auto tmp = b + static_cast<int>(s.length());
a += tmp;
},
data1, data2, data3
);
data1; // { 3.1, 1.2, 11.3, 4.4 }

Definition at line 46 of file for_each.hpp.

template<class F , class... Cs>
void sig::for_each ( F &&  func,
int  init,
Cs &&...  containers 
)

複数コンテナを反復処理 (添字変数の利用可)

1反復毎に1ずつインクリメントされる添字変数を利用可 (initはその初期値).
先頭の要素から順番に関数を適用し、いずれかのコンテナの末尾に到達するまで繰り返す．
引数で渡す関数オブジェクト(orラムダ)の引数を参照(&)にすることで変更操作も可能

Parameters
func関数オブジェクト(第1引数は添字変数.以降の引数の順番は渡すcontainersの順番に対応)
init添字変数の初期値
containers処理対象のコンテナ（対応コンテナ ）
const std::vector<int> data1{ 1, -3, 5 };
const std::list<double> data2{ 1.0, -3.0, 5.0 };
const std::multiset<int, std::greater<int>> data3{ 1, -3, 5 };
const std::map<int, char> data4{ {0, 'a'}, {1, 'b'}, {2, 'c'}, {3, 'd'} };
array<std::string, 3> data5{ "A", "B", "C" };
for_each([](int i, int a, double b, int c, char d, std::string& e)
{
e.append(std::to_string(i) + std::to_string(a + b) + d + std::to_string(c));
},
-1, data1, data2, data3, data4, data5
);

Definition at line 78 of file for_each.hpp.

template<class F , class M >
void sig::for_each_m ( F &&  func,
M &  mat 
)

行列の全要素に対して、代入演算を行う関数を適用する

Definition at line 331 of file ublas.hpp.

template<class F , class V , class... Vs>
void sig::for_each_v ( F &&  func,
V &  vec,
Vs &&...  vecs 
)

ベクトルの全要素に対して、関数を適用する

Definition at line 323 of file ublas.hpp.

template<class M , class R = std::vector<typename M::value_type>>
auto sig::from_matrix_ublas ( M const &  mat,
uint  row 
) -> R

ublas::matrix<T> の指定行を STLのvectorへ変換

Definition at line 128 of file ublas.hpp.

template<class M , class R = std::vector<std::vector<typename M::value_type>>>
auto sig::from_matrix_ublas ( M const &  mat) -> R

ublas::matrix<T> から STLのvectorの2次元配列へ変換

Definition at line 141 of file ublas.hpp.

template<class V , class R = std::vector<typename V::value_type>>
auto sig::from_vector_ublas ( V const &  vec) -> R

ublas::vector<T> から STLのvectorへ変換

Definition at line 115 of file ublas.hpp.

template<class T >
T& sig::fromJust ( Maybe< T > &  m)

Justから値を取り出す関数．Maybe a -> a.

Maybeの正体がNothingオブジェクトの場合、未定義動作

See also
operator*(Maybe<T>& m)
auto m = Just<int>(1);
const auto cm = Just<int>(2);
int v1 = fromJust(m); // v == 1
auto& v2 = fromJust(m); // int&
rv = 5;
assert(*m == 5);
auto& v3 = sig::fromJust(cm); // const int&
auto v4 = sig::fromJust(cm); // int

Definition at line 113 of file maybe.hpp.

template<class T >
T const& sig::fromJust ( Maybe< T > const &  m)

Definition at line 114 of file maybe.hpp.

template<class T >
T&& sig::fromJust ( Maybe< T > &&  m)

Definition at line 115 of file maybe.hpp.

template<class T >
T& sig::fromMaybe ( T &  def,
Maybe< T > &  m 
)

Maybeから値を取り出す関数．もしNothingなら引数のデフォルト値を返す．a -> Maybe a -> a.

auto m = Just<int>(1);
auto n = Nothing(0);
int v = fromMaybe(2, m); // v == 1
int d = fromMaybe(2, n); // d == 2

Definition at line 145 of file maybe.hpp.

template<class T >
T const& sig::fromMaybe ( T const &  def,
Maybe< T > const &  m 
)

Definition at line 146 of file maybe.hpp.

template<class T >
T&& sig::fromMaybe ( T &&  def,
Maybe< T > &&  m 
)

Definition at line 147 of file maybe.hpp.

template<class T >
T&& sig::fromMaybe ( T &&  def,
boost::none_t  m 
)

Definition at line 148 of file maybe.hpp.

template<class CC1 , class CC2 >
auto sig::GaleShapley ( CC1 const &  men_vec,
CC2 const &  women_vec 
)

Definition at line 58 of file others.hpp.

auto sig::get_file_names ( FilepassString const &  directory_pass,
bool  hidden_file,
std::wstring  extension = L"" 
) -> Maybe<std::vector<std::wstring>>
inline

指定ディレクトリにあるファイル名を取得

Precondition
VisualStudio環境 または boostのインクルード
Parameters
directry_pass調べたいディレクトリのパス
hidden_filetrue:隠しファイルのみ, false:非隠しファイルのみ (Windows, Linux環境のみ)
extension[option] 拡張子指定
Returns
ファイル名の一覧

Definition at line 75 of file pass.hpp.

auto sig::get_folder_names ( FilepassString const &  directory_pass,
bool  hidden_file 
) -> Maybe<std::vector<std::wstring>>
inline

指定ディレクトリにあるフォルダ名を取得

Precondition
VisualStudio環境 または boostのインクルード
Parameters
directry_pass調べたいディレクトリのパス
hidden_filetrue:隠しファイルのみ, false:非隠しファイルのみ (Windows, Linux環境のみ)
Returns
フォルダ名の一覧

Definition at line 143 of file pass.hpp.

template<class T1 , class T2 >
constexpr bool sig::greater ( T1  v1,
T2  v2 
)

v1 > v2 であるか確認

static_assert( greater(1, 0), "");

Definition at line 387 of file helper_modules.hpp.

template<class C >
bool sig::has_zero ( C const &  v)

要素の値に0があるか確認

Definition at line 38 of file comparable_check.hpp.

template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto sig::invert_matrix ( matrix_u< T > &&  mat) -> Maybe<matrix_u<RT>>

逆行列を求める

LU分解を用いて逆行列を計算する．
boost.optional有効時には値がラップされて返される

Parameters
mat逆行列を求める行列．この行列自体に変更を加えても良い場合はmoveで渡す
Returns
逆行列

Definition at line 204 of file ublas.hpp.

template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto sig::invert_matrix ( matrix_u< T > const &  mat) -> Maybe<matrix_u<RT>>

Definition at line 223 of file ublas.hpp.

template<class C1 , class C2 >
bool sig::is_comparable ( C1 const &  v1,
C2 const &  v2,
impl::NumericVectorTag   
)

2つのベクトルが比較可能か確認

Definition at line 45 of file comparable_check.hpp.

template<class C1 , class C2 >
bool sig::is_comparable ( C1 const &  v1,
C2 const &  v2,
impl::DistributionTag   
)

2つの確率分布が比較可能か確認

Definition at line 52 of file comparable_check.hpp.

template<class T >
constexpr bool sig::is_finite_number ( T  x)

値が非数(NaN)でなく、かつ無限大(Inf)でないかを確認

double inf = std::numeric_limits<double>::infinity();
double inf2 = product(sig::replicate<double>(1000, 10)); // 10^1000
assert(is_finite_number(0));
assert(!is_finite_number(inf));
assert(!is_finite_number(inf2));

Definition at line 225 of file helper_modules.hpp.

template<class T >
constexpr bool sig::is_number ( T  x)

値が非数(NaN)でないかを確認

double zero = 0;
double nan = std::numeric_limits<double>::quiet_NaN();
assert(is_number(0));
assert(!is_number(nan));
assert(!is_number(zero/zero));
assert(!is_number(std::sqrt(-1)));

Definition at line 207 of file helper_modules.hpp.

template<class C1 , class C2 >
bool sig::is_same_size ( C1 const &  v1,
C2 const &  v2 
)

Definition at line 23 of file comparable_check.hpp.

template<class C1 , class C2 >
bool sig::is_valid_distribution ( C1 const &  v1,
C2 const &  v2 
)

離散確率分布の性質を満たしているか確認

Definition at line 30 of file comparable_check.hpp.

template<class T >
bool sig::isJust ( Maybe< T > const &  m)

Justであるか調べる関数．Maybe a -> Bool.

Definition at line 84 of file maybe.hpp.

constexpr bool sig::isJust ( boost::none_t  m)

Definition at line 85 of file maybe.hpp.

template<class T >
bool sig::isNothing ( Maybe< T > const &  m)

Nothingであるか調べる関数．Maybe a -> Bool.

Definition at line 89 of file maybe.hpp.

constexpr bool sig::isNothing ( boost::none_t  m)

Definition at line 90 of file maybe.hpp.

template<class F , class... Its>
void sig::iterative_assign ( uint  loop,
F &&  func,
Its...  iterators 
)

Definition at line 197 of file container_helper.hpp.

template<class F , class... Its>
void sig::iterative_assign ( uint  loop,
int  init,
F &&  func,
Its...  iterators 
)

Definition at line 204 of file container_helper.hpp.

template<class T , class F1 , class F2 , class... Its>
void sig::iterative_fold ( uint  loop,
T &  dest,
F1 &&  zip,
F2 &&  fold,
Its...  iterators 
)

Definition at line 187 of file container_helper.hpp.

template<class C , class F , class... Its>
void sig::iterative_make ( uint  loop,
C &  dest,
F &&  func,
Its...  iterators 
)

Definition at line 178 of file container_helper.hpp.

template<class T , class R = typename sig::impl::remove_const_reference<T>::type>
Maybe<R> sig::Just ( T &&  v)

値コンストラクタ

auto m1 = Just(1); // :: Maybe<int>
auto m2 = Just<double>(1); // :: Maybe<double>

Definition at line 55 of file maybe.hpp.

template<class T >
Maybe<T> sig::Just ( T const &  v)

Definition at line 58 of file maybe.hpp.

template<class T1 , class T2 >
constexpr bool sig::less ( T1  v1,
T2  v2 
)

v1 < v2 であるか確認

static_assert( less(0, 1), "");

Definition at line 397 of file helper_modules.hpp.

template<class IFS_CHAR , class C , class R = typename impl::container_traits<C>::value_type>
bool sig::load_line ( C &  empty_dest,
std::basic_ifstream< IFS_CHAR > &  ifs 
)

ファイルから1行ずつ読み込む（ifstreamを指定）

Parameters
empty_dest保存先のコンテナ（対応コンテナ )
ifsstd::ifstream or std::wifstream
Returns
読み込みの成否

Definition at line 52 of file load.hpp.

template<class C , class R = typename impl::container_traits<C>::value_type>
bool sig::load_line ( C &  empty_dest,
FilepassString const &  file_pass 
)

ファイルから1行ずつ読み込む（ファイル名を指定）

Parameters
empty_dest保存先のコンテナ（対応コンテナ )
file_pass保存先のパス（ファイル名含む）
Returns
読み込みの成否
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
std::vector<std::string> input;
load_line(input, fpass);

Definition at line 85 of file load.hpp.

template<class ISTR = std::string, class C = std::vector<ISTR>>
auto sig::load_line ( FilepassString const &  file_pass) -> Maybe<C>

ファイルから1行ずつ読み込み、結果を返す（ファイル名を指定）

Template Parameters
ISTR[option] 読み込んだ文字列を保持する型（std::string or std::wstring）
Parameters
file_pass読み込むファイルのパス
Returns
読み込み結果（値はMaybe で返される）
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
auto input = load_line(fpass);
auto& data = *input; // std::vector<std::string>

Definition at line 137 of file load.hpp.

template<class ISTR = std::string, class R = ISTR, class C = std::vector<R>>
auto sig::load_line ( FilepassStringC  file_pass) -> Maybe<C>

file_pass が const char* , const wcahr_t* である場合のオーバーロード

See also
load_line(FilepassString const& file_pass)

Definition at line 162 of file load.hpp.

template<class IFS_CHAR , class F , class C , class R = typename impl::container_traits<C>::value_type>
bool sig::load_line ( C &  empty_dest,
std::basic_ifstream< IFS_CHAR > &  ifs,
F const &  conv 
)

ファイルから1行ずつ読み込み、同時に変換処理を行う（ifstreamを指定）

Parameters
empty_dest保存先のコンテナ（対応コンテナ )
ifsstd::ifstream or std::wifstream
conv読み込んだ文字列から任意型Rへの変換関数(文字列 -> 数値型へはload_numを推奨)

Definition at line 183 of file load.hpp.

template<class ISTR = std::string, class F , class C , class R = typename impl::container_traits<C>::value_type>
bool sig::load_line ( C &  empty_dest,
FilepassString const &  file_pass,
F const &  conv 
)

ファイルから1行ずつ読み込み、同時に変換処理を行う（ファイル名を指定）

Template Parameters
ISTR[option] 読み込んだ文字列を保持する型（std::string or std::wstring）
Parameters
empty_dest保存先のコンテナ（対応コンテナ )
file_pass保存先のパス（ファイル名含む）
conv読み込んだ文字列から任意型Rへの変換関数(文字列 -> 数値型へはload_numを推奨)
struct Test{
int a;
Test(double v, double p) : a(std::pow(v, p)){}
};
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
std::vector<Test> input;
load_line(
input,
fpass,
[&](std::string&& s){
auto tmp = split(s, ","); // example: s = "2.73,0.001"
return Test(tmp[0], tmp[1]);
}
);

Definition at line 233 of file load.hpp.

template<class C , class RT = typename impl::container_traits<C>::value_type, typename std::enable_if<!impl::container_traits< typename impl::container_traits< C >::value_type >::exist >::type *& = enabler>
bool sig::load_num ( C &  empty_dest,
FilepassString const &  file_pass,
std::string  delimiter = "\n" 
)

数値列を読み込む

Parameters
empty_dest保存先のコンテナ（対応コンテナ )
file_pass保存先のパス（ファイル名含む）
delimiter[option] 数値間の区切り文字
Returns
読み込みの成否
Exceptions
std::invalid_argument（数値に変換できない場合）,std::out_of_range（intやdouble等で変換可能な値の範囲を超えている場合）n
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass1 = dir + SIG_TO_FPSTR("test1.txt");
const auto fpass2 = dir + SIG_TO_FPSTR("test2.txt");
std::vector<double> input1;
std::set<double> input2;
load_num(input1, fpass1);
load_num(input2, fpass2, ",");
// test1.txt
1.1
2.2
3.3
// test2.txt
1.1,2.2,3.3

Definition at line 293 of file load.hpp.

template<class R , class C = std::vector<R>, typename std::enable_if< impl::container_traits< C >::exist &&!impl::container_traits< typename impl::container_traits< C >::value_type >::exist >::type *& = enabler>
auto sig::load_num ( FilepassString const &  file_pass,
std::string  delimiter = "\n" 
) -> Maybe<C>

数値列を読み込み、結果を返す

Template Parameters
R数値の型（int, double等）
C[option] コンテナの型（対応コンテナ )
Parameters
file_pass保存先のパス（ファイル名含む）
delimiter[option] 数値間の区切り文字
Returns
読み込み結果（値はMaybe で返される）
Exceptions
std::invalid_argument（数値に変換できない場合）,std::out_of_range（intやdouble等で変換可能な値の範囲を超えている場合）n
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass1 = dir + SIG_TO_FPSTR("test1.txt");
const auto fpass2 = dir + SIG_TO_FPSTR("test2.txt");
auto input1 = load_num<double>(fpass1);
auto input2 = load_num<double, std::set<double>>(fpass2, ",");
// test1.txt
1.1
2.2
3.3
// test2.txt
1.1,2.2,3.3

Definition at line 351 of file load.hpp.

template<class CC , class RC = typename impl::container_traits<CC>::value_type, class RT = typename impl::container_traits<RC>::value_type>
bool sig::load_num2d ( CC &  empty_dest,
FilepassString const &  file_pass,
std::string  delimiter 
)

2次元配列の数値(ex:行列)を読み込む

Parameters
empty_dest保存先のコンテナ（対応コンテナ )
file_pass保存先のパス（ファイル名含む）
delimiter数値間の区切り文字
Returns
読み込みの成否
Exceptions
std::invalid_argument（数値に変換できない場合）,std::out_of_range（intやdouble等で変換可能な値の範囲を超えている場合）n
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
array<std::vector<int>, 3> input_mat;
load_num2d(input_mat, fpass, ",");
assert(input_mat[2][0], 7);
// test.txt
1,2,3
4,5,6,7
8,9

Definition at line 397 of file load.hpp.

template<class R , class CC = std::vector<std::vector<R>>, typename std::enable_if< impl::container_traits< typename impl::container_traits< CC >::value_type >::exist >::type *& = enabler>
auto sig::load_num2d ( FilepassString const &  file_pass,
std::string  delimiter 
) -> Maybe<CC>

2次元配列の数値(ex:行列)を読み込む

Template Parameters
R数値の型（int, double等）
CC[option] コンテナの型（対応コンテナ )
Parameters
file_pass保存先のパス（ファイル名含む）
delimiter数値間の区切り文字
Returns
読み込み結果（値はMaybe で返される）
Exceptions
std::invalid_argument（数値に変換できない場合）,std::out_of_range（intやdouble等で変換可能な値の範囲を超えている場合）n
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
auto input_mat = load_num2d<double>(input_mat, fpass, ",");
assert(input_mat[2][0], 7);
// test.txt
1,2,3
4,5,6,7
8,9

Definition at line 450 of file load.hpp.

template<class S >
auto sig::make_regex ( S const &  expression) -> typename impl::Str2RegexSelector<impl::string_t<S>>::regex

エスケープ処理を行い、regexオブジェクトを返す

Parameters
expression正規表現の文字列
Returns
std::regex or std::wregex (libstdc++使用時 かつ boost使用時は boost::regex)
auto reg = make_regex(L"(笑)");
// SIG_RegexReplace is std::regex_replace or boost::regex_replace
auto replaced = SIG_RegexReplace(std::wstring(L"てすと(笑)です"), reg, std::wstring(L""));
assert(replaced == L"てすとです");

Definition at line 148 of file regex.hpp.

template<class C = std::vector<int>>
C sig::make_unique_numbers ( uint  n,
int  min,
int  max,
bool  debug 
)

重複の無い一様分布の整数乱数を生成

Parameters
n発生させる値の個数
min最小値
max最大値
debug乱数のシードを固定するか
Returns
生成した乱数を格納したコンテナ
auto rints = make_unique_numbers(10, 0, 20, true); // [0, 20]の一様分布から10個重複無くサンプル
for (auto v : rints) std::cout << v << std::endl;

Definition at line 85 of file random.hpp.

template<class F , class C >
auto sig::map ( F &&  func,
C &&  list 
)

1引数高階関数

(a -> b) -> [a] -> [b]
コンテナの各要素に関数を適用し、結果を新たなコンテナに格納する

Parameters
func関数 (a -> b)
listデータが格納されたコンテナ [a]（対応コンテナ ）
Returns
処理結果のコンテナ [b]（コンテナはlistと同じ種類）
const array<int, 3> data1{ 1, -3, 5 }; // sig::array
const std::unordered_set<double> data2{ 0, 1.1, -2.2, 3.3 };
auto r1 = map(increment_t(), data1);
auto r2 = map([](double v){ return v * 2; }, data2);
r1; // array<int, 3>{ 2, -2, 6 }
r2; // std::unordered_set<double>{ 0, 2.2, -4.4, 6.6 }

Definition at line 62 of file high_order.hpp.

template<class F , class M >
auto sig::map_m ( F &&  func,
M &&  mat 
)

Definition at line 302 of file ublas.hpp.

template<class F , class V >
auto sig::map_v ( F &&  func,
V &&  vec 
)

ベクトルの全要素に対して、値を返す関数を適用し、その結果のベクトルを返す

Definition at line 287 of file ublas.hpp.

template<class F , class C >
auto sig::mapMaybe ( F const &  f,
C const &  list 
) -> typename impl::container_traits<C>::template rebind< typename std::remove_reference<decltype(*(impl::eval( f, std::declval<typename impl::container_traits<C>::value_type>() )))>::type >

Maybeを返す関数を指定するfilter関数．(a -> Maybe b) -> [a] -> [b].

コンテナの各要素にMaybeを返す関数を適用し、結果がJustであれば値を保存し、Nothingであれば無視する

Parameters
fMaybeを返す関数
list対応コンテナ
Returns
結果を格納したlistと同じ種類のコンテナ
std::vector<int> vec{ 1, 2, 3 };
auto vecd = mapMaybe([](int v){ return v != 2 ? Just<double>(v *1.5) : Nothing(0); }, vec);
vecd[0]; // 1.5
vecd[1]; // 4.5
vecf[2]; // out of range. undefined behavior

Definition at line 168 of file maybe.hpp.

template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto sig::matrix_vector_solve ( matrix_u< T > &&  mat,
vector_u< T > &&  vec 
) -> Maybe<vector_u<RT>>

連立方程式を解く

Definition at line 236 of file ublas.hpp.

template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto sig::matrix_vector_solve ( matrix_u< T > const &  mat,
vector_u< T > const &  vec 
) -> Maybe<vector_u<RT>>

Definition at line 253 of file ublas.hpp.

template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto sig::matrix_vector_solve ( matrix_u< T > const &  mat,
vector_u< T > &&  vec 
) -> Maybe<vector_u<RT>>

Definition at line 265 of file ublas.hpp.

template<class T , class RT = typename std::conditional<std::is_integral<T>::value, double, T>::type>
auto sig::matrix_vector_solve ( matrix_u< T > &&  mat,
vector_u< T > const &  vec 
) -> Maybe<vector_u<RT>>

Definition at line 276 of file ublas.hpp.

template<class T >
auto sig::max ( T  v) -> T

Definition at line 160 of file helper_modules.hpp.

template<class T1 , class T2 >
auto sig::max ( T1  v1,
T2  v2 
)

Definition at line 169 of file helper_modules.hpp.

template<class T , class... Ts>
auto sig::max ( T  v,
Ts...  vs 
)

可変長 max

Parameters
v,vs大小比較可能な変数（数値を表すPOD型 または operator < が定義されたオブジェクト）
Returns
最大の要素
static_assert( max(1, -1, 0, 3, 2) == 3, "");

Definition at line 188 of file helper_modules.hpp.

template<class C , class R = typename impl::remove_const_reference<C>::type, typename std::enable_if<!impl::static_container_traits< R >::exist >::type *& = enabler>
auto sig::merge ( C &&  list1,
C &&  list2 
) -> R

コンテナの結合（同じコンテナ型）

[a] -> [a] -> [a]
非シーケンスコンテナの場合、結合後の要素の順番は保たれない

Parameters
list1結合後に前に位置するコンテナ（対応コンテナ ）
list2結合後に後ろに位置するコンテナ（対応コンテナ ）
Returns
結果のコンテナ（コンテナはlist1と同じ種類）
See also
merge(C1&& list1, C2&& list2)
const array<int, 3> data1{ 1, 2, 3 }; // sig::array
const array<int, 3> data2{ 4, 5, 6 }; // sig::array
auto m = merge(data1, data2); // array<int, 6>{ 1, 2, 3, 4 , 5, 6 }

Definition at line 94 of file list_deal.hpp.

template<class R = void, class C1 , class C2 , class CR1 = typename impl::remove_const_reference<C1>::type, class CR2 = typename impl::remove_const_reference<C2>::type, class RT = typename std::common_type< typename impl::container_traits<CR1>::value_type, typename impl::container_traits<CR2>::value_type >::type, class RR = typename impl::SameIf<R, void, typename impl::remove_const_reference< typename impl::container_traits<CR1>::template rebind<RT>>::type, R >::type, class AT1 = typename impl::forward_element<C1>::type, class AT2 = typename impl::forward_element<C2>::type, typename std::enable_if<!(impl::static_container_traits< CR1 >::exist)>::type *& = enabler>
auto sig::merge ( C1 &&  list1,
C2 &&  list2 
) -> RR

[a] -> [b] -> [c]
ただし、cはstd::common_type<a, b>::type
非シーケンスコンテナの場合、結合後の要素の順番は保たれない

Template Parameters
R[option] 返り値のコンテナ型を指定（対応コンテナ ）
Parameters
list1結合後に前に位置するコンテナ（対応コンテナ ）
list2結合後に後ろに位置するコンテナ（対応コンテナ ）
Returns
結果のコンテナ（コンテナは R もしくは list1と同じ種類）
const array<int, 4> data1{ 1, 2, 3, 4 }; // sig::array
const array<double, 3> data2{ 5.5, 6.6, 7.7 }; // sig::array
std::vector<int> data3{ 1, -3 };
auto m1 = merge(data1, data2); // array<double, 7>{ 1, 2, 3, 4, 5.5, 6.6, 7.7 }
auto m2 = merge(data2, data3); // std::vector<double>{ 5.5, 6.6, 7.7, 1, -3 }
auto m3 = merge<std::set<double, std::greater<double>>>(data1, data2); // std::set<double>{ 7.7, 6.6, 5.5, 4, 3, 2, 1 }

Definition at line 163 of file list_deal.hpp.

template<class R = void, class SC , class C , class SCR = typename impl::remove_const_reference<SC>::type, class CR = typename impl::remove_const_reference<C>::type, class RT = typename std::common_type< typename impl::static_container_traits<SCR>::value_type, typename impl::container_traits<CR>::value_type >::type, class RR = typename impl::SameIf<R, void, typename impl::remove_const_reference< typename impl::container_traits<CR>::template rebind<RT>>::type, R >::type, typename std::enable_if< impl::static_container_traits< SCR >::exist &&(!impl::static_container_traits< CR >::exist)>::type *& = enabler>
auto sig::merge ( SC &&  list1,
C &&  list2 
) -> RR

Definition at line 181 of file list_deal.hpp.

template<class R = void, class SC1 , class SC2 , class SCR1 = typename impl::remove_const_reference<SC1>::type, class SCR2 = typename impl::remove_const_reference<SC2>::type, class RT = typename std::common_type< typename impl::static_container_traits<SCR1>::value_type, typename impl::static_container_traits<SCR2>::value_type >::type, class RR = typename impl::SameIf<R, void, typename impl::static_container_traits<SCR1>::template rebind_t<RT, impl::plus_t<impl::static_container_traits<SCR1>::size, impl::static_container_traits<SCR2>::size>::value>, R >::type, typename std::enable_if< impl::static_container_traits< SCR1 >::exist &&impl::static_container_traits< SCR2 >::exist >::type *& = enabler>
auto sig::merge ( SC1 &&  list1,
SC2 &&  list2 
) -> RR

Definition at line 199 of file list_deal.hpp.

template<class T >
auto sig::min ( T  v) -> T

Definition at line 122 of file helper_modules.hpp.

template<class T1 , class T2 >
auto sig::min ( T1  v1,
T2  v2 
)

Definition at line 131 of file helper_modules.hpp.

template<class T , class... Ts>
auto sig::min ( T  v,
Ts...  vs 
)

可変長 min

Parameters
v,vs大小比較可能な変数（数値を表すPOD型 または operator < が定義されたオブジェクト）
Returns
最小の要素
static_assert( min(1, -1, 0, 3, 2) == -1, "");

Definition at line 150 of file helper_modules.hpp.

template<class T1 , class T2 >
auto sig::minus ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(minus_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 135 of file binary_operation.hpp.

auto sig::modify_dirpass_tail ( FilepassString const &  directory_pass,
bool const  has_slash 
) -> FilepassString
inline

ディレクトリ・ファイルパスの末尾に'/'or'\'があるかチェックし、付けるか外すかどうかを指定して反映

Parameters
directory_passチェックするパスの文字列
has_slash末尾に'/'or'\'を付けるかどうか
Returns
修正したパスの文字列
auto pass = SIG_TO_FPSTR("../SigUtil/example");
auto mpass = modify_dirpass_tail(pass, true); // "../SigUtil/example/"

Definition at line 43 of file pass.hpp.

template<class T , class U >
bool sig::modify_range ( T &  val,
U const &  min,
U const &  max 
)

値を範囲内に自動修正

min ≦ val ≦ max であるか確認し、範囲を超えている場合は最も近い範囲内の値（min または max）に修正

Parameters
val確認したい値
min範囲の下限
max範囲の上限
Returns
valが修正されたか
int mr = 5;
assert(sig::modify_range(mr, 0, 10));
assert(mr == 5);
assert(!sig::modify_range(mr, 0, 3));
assert(mr == 3);

Definition at line 371 of file helper_modules.hpp.

template<class T1 , class T2 >
auto sig::mult ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(mult_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 143 of file binary_operation.hpp.

template<class C , typename std::enable_if< std::is_floating_point< typename impl::container_traits< C >::value_type >::value >::type *& = enabler>
bool sig::normalize ( C &  data)

正規化（Normalization）

最小値0、最大値1とし、各値が[0,1]の範囲に収まるように正規化.
normalize(C const& data, int dummy = 0)ではなくこちらが呼び出されているかを確認するには、返り値をboolで受けるようにする

Parameters
data正規化を行いたい値集合（対応コンテナ ）．要素型は浮動小数点型であることが条件
Returns
なし
array<double, 5> ar{ -5, -2, 0, 1, 5 }; // sig::array
bool ck = normalize(ar);
ar; // { 0, 0.3, 0.5, 0.6, 1 }

Definition at line 266 of file basic_statistics.hpp.

template<class R = double, class C = void>
auto sig::normalize ( C const &  data,
int  dummy = 0 
) -> typename impl::container_traits<C>::template rebind<R>

正規化（Normalization）

最小値0、最大値1とし、各値が[0,1]の範囲に収まるように正規化． normalize(C& data)ではなく明示的にこちらを呼び出す場合は、第2引数を指定

Parameters
data正規化を行いたい値集合（対応コンテナ ）
Returns
正規化を行った結果
const array<double, 5> ar1{ -5, -1.5, 0, 0.5, 5 }; // sig::array
array<double, 5> ar2{ -5, -1.5, 0, 0.5, 5 }; // sig::array
auto normal1 = normalize(ar1); // { 0, 0.35, 0.5, 0.55, 1 }
// 第2引数はダミー(ar2はconstでないため、オーバーロード解決でこの関数を呼び出すために必要)
auto normal2 = normalize(ar2, 0); // { 0, 0.35, 0.5, 0.55, 1 }

Definition at line 303 of file basic_statistics.hpp.

template<class C , typename std::enable_if< std::is_floating_point< typename impl::container_traits< C >::value_type >::value >::type *& = enabler>
bool sig::normalize_dist ( C &  data)

確率分布の正規化

各値の総和が1になるよう[0,1]の範囲に正規化.
normalize_dist(C const& data, int dummy = 0)ではなくこちらが呼び出されているかを確認するには、返り値をboolで受けるようにする

Parameters
data正規化を行いたい値集合（対応コンテナ ）．要素型は浮動小数点型であることが条件
Returns
なし
array<double, 5> ar{ 1, 2, 4, 2, 1 };
bool ck = normalize_dist(ar);
ar; // { 0.1, 0.2, 0.4, 0.2, 0.1 }

Definition at line 394 of file basic_statistics.hpp.

template<class R = double, class C = void>
auto sig::normalize_dist ( C const &  data,
int  dummy = 0 
) -> typename impl::container_traits<C>::template rebind<R>

確率分布の正規化

各値の総和が1になるよう[0,1]の範囲に正規化.
normalize_dist(C& data)ではなく明示的にこちらを呼び出す場合は、第2引数を指定

Parameters
data正規化を行いたい値集合（対応コンテナ ）
Returns
正規化を行った結果
const array<int, 5> ar1{ 1, 2, 4, 2, 1 }; // sig::array
array<double, 5> ar2{ 0.2, 0.5, 1.4, 0.3, 0.8 }; // sig::array
auto nd1 = normalize_dist(ar1); // { 0.1, 0.2, 0.4, 0.2, 0.1 }
// 第2引数はダミー(ar2はconstでないため、オーバーロード解決でこの関数を呼び出すために必要)
auto nd2 = normalize_dist(ar2, 0); // { 0.0625, 0.15625, 0.4375, 0.09375, 0.25 }

Definition at line 422 of file basic_statistics.hpp.

template<class V , typename std::enable_if< std::is_floating_point< typename V::value_type >::value >::type *& = enabler>
bool sig::normalize_dist_v ( V &  data)

Definition at line 360 of file ublas.hpp.

template<class V >
auto sig::normalize_dist_v ( V const &  data,
int  dummy = 0 
)

Definition at line 369 of file ublas.hpp.

template<class T = void>
auto sig::Nothing ( ) -> typename impl::SameIf<T, void, typename boost::none_t, Maybe<T>>::type

値コンストラクタ

auto n = Nothing(); // :: Maybe<int>

Definition at line 67 of file maybe.hpp.

template<class T >
auto sig::Nothing ( T const &  dummy) -> Maybe<T>

値コンストラクタ

引数はダミー（optional無効時にも統一的に記述できるようにするために存在）

auto n = Nothing(0); // :: Maybe<int>

Definition at line 80 of file maybe.hpp.

template<class T >
T& sig::operator* ( Maybe< T > &  m)

fromJust演算子

fromJust関数の演算子版．
Maybeの正体がNothingオブジェクトの場合、未定義動作

See also
fromJust(Maybe<T>& m)
auto m = Just<int>(1);
int v = *m; // v == 1

Definition at line 130 of file maybe.hpp.

template<class T >
T const& sig::operator* ( Maybe< T > const &  m)

Definition at line 131 of file maybe.hpp.

template<class T >
T&& sig::operator* ( Maybe< T > &&  m)

Definition at line 132 of file maybe.hpp.

template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto sig::operator* ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(mult_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 195 of file binary_operation.hpp.

template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto sig::operator+ ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(plus_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 165 of file binary_operation.hpp.

template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto sig::operator- ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(minus_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 180 of file binary_operation.hpp.

template<class T1 , class T2 , class TR1 = typename impl::remove_const_reference<T1>::type, class TR2 = typename impl::remove_const_reference<T2>::type, typename std::enable_if< impl::container_traits< TR1 >::exist||impl::container_traits< TR2 >::exist >::type *& = enabler>
auto sig::operator/ ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(div_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 210 of file binary_operation.hpp.

template<class F , class T >
auto sig::operator<<= ( F const &  f,
Maybe< T > const &  m 
) -> decltype(impl::eval(f, std::declval<T>()))

C++に合わせたbind演算子. Maybe m => (a -> m b) -> m a -> m b.

C++では operator>>= と operator<<= は右結合であるため、処理が右端から順番に流れていく方が自然に記述できる（以下のサンプルコード参照）

Parameters
f適用する関数
maMaybeオブジェクト
Returns
関数適用結果が格納されたMaybeオブジェクト
See also
operator>>=(Maybe<T> const& m, F const& f)
// using sig::operator<<=; // required in non-sig namespace
auto m = Just<int>(1);
auto f = [&](int v){ return sig::Just(v * 1.5); }; // (a -> m b)
auto mm = [&](double v){ return Just(std::to_string(v)); } <<= f <<= m; // suitable style for C++
assert(equal(*mm, std::to_string(4.5)));

Definition at line 241 of file maybe.hpp.

template<class T1 , class T2 >
auto sig::operator<<= ( Maybe< T1 > &  m,
T2 const &  v 
) -> Maybe<T1>&

Maybeオブジェクトへの再代入を行う演算子

関数型言語では再代入は不可能な機能であるが、C++では無いと不便であるためこの関数を作成．
Maybeオブジェクトへの再代入をJust, Nothingに関係なく統一的に記述することが目的

Parameters
mMaybeオブジェクト
v代入したい値
Returns
mへの参照
// using sig::operator<<=; // required in non-sig namespace
auto m = Just<int>(1);
auto n = Nothing();
m <<= 2;
n <<= 2;
int v1 = *m; // v1 == 2
int v2 = *n; // v2 == 2

Definition at line 273 of file maybe.hpp.

template<class T , class F >
auto sig::operator>>= ( Maybe< T > const &  m,
F const &  f 
) -> decltype(impl::eval(f, std::declval<T>()))

Haskell風のbind演算子. Maybe m => m a -> (a -> m b) -> m b.

C++では operator>>= は右結合であるため、連鎖させる際には明示的に()を使う必要あり（以下のサンプルコード参照）

Parameters
maMaybeオブジェクト
f適用する関数
Returns
関数適用結果が格納されたMaybeオブジェクト
See also
operator<<=(F const& f, Maybe<T> const& m)
// using sig::operator>>=; // required in non-sig namespace
auto m = Just<int>(1);
auto f = [&](int v){ return sig::Just(v * 1.5); }; // (a -> m b)
auto mm = (m >>= f) >>= [&](double v){ return Just(std::to_string(v)); }; // Haskell Style
assert(equal(*mm, std::to_string(4.5)));

Definition at line 212 of file maybe.hpp.

template<class B >
bool sig::Or ( B &&  cond)

Definition at line 52 of file helper_modules.hpp.

template<class B1 , class... Bs>
bool sig::Or ( B1 &&  cond,
Bs &&...  conds 
)

可変長 or

Parameters
cond,condsbool変数 または operator boolが定義されたオブジェクト
Returns
全引数に対してorを取った結果
static_assert(!Or(false, false, false), "");
static_assert(Or(false, true, false, true, false), "");

Definition at line 70 of file helper_modules.hpp.

template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class ET = typename impl::forward_element<C>::type>
auto sig::partition ( F &&  pred,
C &&  list 
)

コンテナから指定条件を満たす要素とそれ以外の要素とを分離する

(a -> Bool) -> [a] -> ([a], [a])

Parameters
pred条件判定を行う述語関数 (a -> Bool)
listデータが格納されたコンテナ [a]（対応コンテナ ）
Returns
処理結果のタプル ([a], [a])（コンテナ2つはlistと同じ種類）
const array<int, 3> data1{ 1, -3, 2 }; // sig::array
const std::unordered_set<double> data2{ 0, 1.1, -2.2, 3.3 };
auto pt1 = partition([](int v){ return v % 2; }, data1);
auto pt2 = partition([](double v){ return v < 0; }, data2);
auto pt1_t = std::get<0>(pt1); // array<int, 3>{ 1, -3 }
auto pt1_f = std::get<1>(pt1); // array<int, 3>{ 2 }
auto pt2_t = std::get<0>(pt2); // std::unordered_set<double>{ -2.2 }
auto pt2_f = std::get<1>(pt2); // std::unordered_set<double>{ 0, 1.1, 3.3 }

Definition at line 114 of file filter.hpp.

template<class T1 , class T2 >
auto sig::plus ( T1 &&  v1,
T2 &&  v2 
) -> decltype(binary_operation(plus_t(), std::forward<T1>(v1), std::forward<T2>(v2)))

Definition at line 127 of file binary_operation.hpp.

void sig::Print ( std::string const &  text,
char const *const  delimiter = "\n" 
)
inline

Definition at line 34 of file others.hpp.

void sig::Print ( std::wstring const &  text,
wchar_t const *const  delimiter = L"\n" 
)
inline

Definition at line 39 of file others.hpp.

template<class T , template< class...> class Container, typename std::enable_if<!std::is_same< T, std::wstring >::value >::type *& = enabler>
void sig::Print ( Container< T > const &  container,
char const *const  delimiter = "\n" 
)
inline

Definition at line 45 of file others.hpp.

template<template< class...> class Container>
void sig::Print ( Container< std::wstring > const &  container,
wchar_t const *const  delimiter = L"\n" 
)
inline

Definition at line 51 of file others.hpp.

template<class R = void, class C = void>
auto sig::product ( C const &  data) -> typename impl::SameIf<R, void, typename impl::container_traits<C>::value_type, R>::type

総乗

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
data総乗を求めたい値集合（対応コンテナ ）
Returns
計算結果
std::vector<int> vec{2,3,4};
std::set<double> set{1.1, 2.2, 3.3};
int p1 = product(vec); // 24
double p2 = prodyct(set); // 7.986

Definition at line 131 of file basic_statistics.hpp.

template<class R = void, class C = void, class Pred = void>
auto sig::product ( C const &  data,
Pred const &  access_func 
) -> typename impl::SameIf<R, void, decltype(impl::eval(access_func, std::declval<typename impl::container_traits<C>::value_type>())), R>::type

総乗

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
data総乗を求めたい値集合（対応コンテナ ）
access_funcコンテナの要素にアクセスし、そのオブジェクトから値を取得する関数
Returns
計算結果
array<std::tuple<int, int>, 2> ar{std::make_tuple(1, -2), std::make_tuple(3, -4)};
int p = product(ar, [](std::tuple<int, int> const& e){ return std::get<1>(e); }); // 8

Definition at line 155 of file basic_statistics.hpp.

template<class R = void, class CC = void>
auto sig::product_col ( CC const &  matrix,
uint  index 
)

行列の指定列の総乗

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
matrix行列（ランダムアクセス可能な2次元コンテナ）
index総乗を求めたい列番号
Returns
計算結果
array<array<int, 3>, 2> mat{ { 1, 2, 3 }, { 4, 5, 6 } }; // sig::array
int pr = product_col(mat, 1); // 10

Definition at line 202 of file basic_statistics.hpp.

template<class R = void, class CC = void>
auto sig::product_row ( CC const &  matrix,
uint  index 
)

行列の指定行の総乗

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
matrix行列（ランダムアクセス可能な2次元コンテナ）
index総乗を求めたい行番号
Returns
計算結果
array<array<int, 3>, 2> mat{ { 1, 2, 3 }, { 4, 5, 6 } }; // sig::array
int pr = product_row(mat, 1); // 120

Definition at line 180 of file basic_statistics.hpp.

template<class C , class R = typename container_traits<C>::value_type>
bool sig::read_line ( C &  empty_dest,
IfsSelector< R > &  ifs,
std::function< R(typename impl::SameIf< R, std::string, std::string, std::wstring >::type) > const &  conv = nullptr 
)

Definition at line 302 of file file_tmp(save,read num).hpp.

template<class C , class R = typename container_traits<C>::value_type>
bool sig::read_line ( C &  empty_dest,
FilepassString const &  file_pass,
std::function< R(typename impl::SameIf< R, std::string, std::string, std::wstring >::type)> const &  conv = nullptr 
)

Definition at line 324 of file file_tmp(save,read num).hpp.

template<class R , class C = std::vector<R>>
auto sig::read_line ( IfsSelector< R > &  ifs) -> Just<C>

Definition at line 342 of file file_tmp(save,read num).hpp.

template<class R , class C = std::vector<R>>
auto sig::read_line ( FilepassString const &  file_pass) -> Just<C>

Definition at line 354 of file file_tmp(save,read num).hpp.

template<class R , class C = std::vector<R>>
auto sig::read_line ( FilepassStringC  file_pass) -> Just<C>

Definition at line 365 of file file_tmp(save,read num).hpp.

template<class C , class RT = typename container_traits<C>::value_type, typename std::enable_if<!container_traits< typename container_traits< C >::value_type >::exist >::type *& = enabler>
bool sig::read_num ( C &  empty_dest,
FilepassString const &  file_pass,
std::string  delimiter = "\n" 
)

Definition at line 377 of file file_tmp(save,read num).hpp.

template<class CC , class RC = typename container_traits<CC>::value_type, class RT = typename container_traits<RC>::value_type>
bool sig::read_num ( CC &  empty_dest,
FilepassString const &  file_pass,
std::string  delimiter1 = "\n",
std::string  delimiter2 = "\n\n" 
)

Definition at line 406 of file file_tmp(save,read num).hpp.

template<class C , typename std::enable_if< container_traits< C >::exist &&!container_traits< typename container_traits< C >::value_type >::exist >::type *& = enabler>
auto sig::read_num ( FilepassString const &  file_pass,
std::string  delimiter = "\n" 
) -> Just<C>

Definition at line 432 of file file_tmp(save,read num).hpp.

template<class S , class TS = impl::string_t<S>>
auto sig::regex_search ( S &&  src,
typename impl::Str2RegexSelector< TS >::regex const &  expression 
) -> Maybe<std::vector<std::vector<TS>>>

std::regex_search のラッパ関数

探索結果にアクセスしやすい様に二次元配列（vector<vector<string>>）に結果を格納している

Parameters
src探索対象の文字列
expression正規表現オブジェクト
Returns
探索成功時には、result[マッチした箇所の順番][マッチ内の参照の順番. 0は全文, 1以降は参照箇所]を内包したMaybe を返す
auto src = "test tes1 tes2";
auto result= regex_search(src, std::regex("tes(\\d)")); // [[tes1, 1], [tes2, 2]]
assert(result[0][0] == "tes1");
assert(result[1][0] == "tes2");

Definition at line 172 of file regex.hpp.

template<class C >
bool sig::remove_all ( C &  container,
typename boost::call_traits< typename impl::container_traits< C >::value_type >::param_type  remove 
)

コンテナから指定した値を全削除

Parameters
container処理対象コンテナ（対応コンテナ ）
remove削除したい値
Returns
削除値が存在したか(bool)
array<std::string, 4> data1{ "a", "b", "c", "b" };
std::vector<int> data2{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
std::unordered_multiset<int> data3{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
remove_all(data1, "b"); // true
remove_all(data2, 3); // true
remove_all(data3, 10); // false
data1; // { "a", "c" }
data2; // { 1, 5, 0, 4, 0, 1 }
data3; // { 1, 5, 3, 3, 0, 4, 0, 1, 3 }

Definition at line 148 of file remove.hpp.

template<class Pred , class C >
bool sig::remove_all_if ( C &  container,
Pred  remove_pred 
)

コンテナから述語条件を満たす値を全削除

Parameters
container処理対象コンテナ（対応コンテナ ）
remove_pred削除するか判断を行う関数オブジェクト
Returns
削除値が存在したか
std::list<int> data{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
remove_all_if(data, [](int v){ return v == 3; });
data; // { 1, 5, 0, 4, 0, 1 }

Definition at line 173 of file remove.hpp.

template<class C , class CR = typename impl::remove_const_reference<C>::type, class T = typename impl::container_traits<CR>::value_type>
auto sig::remove_duplicates ( C &  container)

コンテナの要素から重複した値を削除

Parameters
container処理対象コンテナ（対応コンテナ ）
Returns
std::map<削除値, その個数>
array<std::string, 4> data1{ "a", "b", "c", "b" };
std::vector<int> data2{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
std::unordered_multiset<int> data3{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
auto removed1 = remove_duplicates(data1); // { "a", "b", "c" }
auto removed2 = remove_duplicates(data2); // { 1, 5, 3, 0, 4 }
auto removed3 = remove_duplicates(data3); // { 1, 5, 3, 0, 4 } 順不同

Definition at line 38 of file remove.hpp.

template<class C >
bool sig::remove_one ( C &  container,
typename boost::call_traits< typename impl::container_traits< C >::value_type >::param_type  remove 
)

コンテナから指定した値を1つ削除

Parameters
container処理対象コンテナ（対応コンテナ ）
remove削除したい値
Returns
削除値が存在したか(bool)
array<std::string, 4> data1{ "a", "b", "c", "b" };
std::vector<int> data2{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
std::unordered_multiset<int> data3{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
remove_one(data1, "b"); // true
remove_one(data2, 3); // true
remove_one(data3, 10); // false
data1; // { "a", "c", "b" }
data2; // { 1, 5, 3, 0, 4, 0, 1, 3 }
data3; // { 1, 5, 3, 3, 0, 4, 0, 1, 3 }

Definition at line 85 of file remove.hpp.

template<class Pred , class C >
bool sig::remove_one_if ( C &  container,
Pred  remove_pred 
)

コンテナから述語条件を満たす値を1つ削除

Parameters
container処理対象コンテナ（対応コンテナ ）
remove_pred削除するか判断を行う関数オブジェクト
Returns
削除値が存在したか(bool)
std::list<int> data{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
remove_one_if(data, [](int v){ return v == 3; });
data; // { 1, 5, 3, 0, 4, 0, 1, 3 }

Definition at line 113 of file remove.hpp.

template<class T , class C = std::vector<T>>
auto sig::replicate ( uint  n,
T const &  value 
) -> C

値を複製したコンテナを返す

uint -> a -> [a]

Parameters
n複製する数 uint
value複製する値 a
Returns
結果のコンテナ [a]（defaultは std::vector）
auto rep1 = replicate(3, 3.14); // std::vector<double>{ 3.14, 3.14, 3.14 }
auto rep2 = replicate(2, std::string("rep")); // std::vector<std::string>{ "rep", "rep" }

Definition at line 33 of file list_deal.hpp.

template<class C >
auto sig::reverse ( C &&  list) -> typename impl::remove_const_reference<C>::type

コンテナの要素の順番を逆転させたコンテナを返す

[a] -> [a]

Parameters
listソースとなるコンテナ（対応コンテナ ）
Returns
結果のコンテナ（コンテナはlistと同じ種類）
const array<int, 4> data1{ 1, 2, 3, 4 }; // sig::array
std::vector<int> data2{ 1, -3, 5, 2, 10 };
auto r1 = reverse(data1); // array<int, 4>{ 4, 3, 2, 1 }
auto r2 = reverse(std::move(data2)); // std::vector<int>{ 10, 2, 5, -3, 1 }
assert(data2.size() == 0);

Definition at line 62 of file list_deal.hpp.

template<class T , typename std::enable_if<!impl::container_traits< T >::exist >::type *& = enabler>
void sig::save_line ( T  src,
typename impl::FStreamSelector< T >::ofstream &  ofs 
)
inline

ファイルへ1行ずつ保存

Parameters
src保存対象
ofsstd::ofstream or std::wofstream

Definition at line 59 of file save.hpp.

template<class C , typename std::enable_if< impl::container_traits< C >::exist >::type *& = enabler>
void sig::save_line ( C const &  src,
typename impl::FStreamSelector< typename impl::container_traits< C >::value_type >::ofstream &  ofs 
)

ファイルへ1行ずつまとめて保存

Parameters
src保存対象（対応コンテナ ）
ofsstd::ofstream or std::wofstream

Definition at line 74 of file save.hpp.

template<class T , typename std::enable_if<!impl::container_traits< T >::exist >::type *& = enabler>
void sig::save_line ( T  src,
FilepassString const &  file_pass,
WriteMode  open_mode = WriteMode::overwrite 
)

ファイルへ1行ずつ保存

file_passで指定したテキストファイルに、srcの内容を書き込み、最後に改行する．
指定したファイルが存在しない場合、新たにファイルが作成される．

Parameters
src保存対象（非コンテナ）
file_pass保存先のパス（ファイル名含む）
open_mode[option] 上書き(overwrite) or 追記(append)
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
std::string str{ "str test" };
std::wstring wstr{ L"wstr test" };
save_line(str, fpass); // 上書き
save_line(wstr, fpass, WriteMode::append); // 末尾に追記
// test.txt
str test
wstr test

Definition at line 115 of file save.hpp.

template<class C , typename std::enable_if< impl::container_traits< C >::exist >::type *& = enabler>
void sig::save_line ( C const &  src,
FilepassString const &  file_pass,
WriteMode  open_mode = WriteMode::overwrite 
)

ファイルへ1行ずつまとめて保存

file_passで指定したテキストファイルに、srcの内容をコンテナの1要素を1行として書き込む．
指定したファイルが存在しない場合、新たにファイルが作成される．

Parameters
src保存対象（対応コンテナ ）
file_pass保存先のパス（ファイル名含む）
open_mode[option] 上書き(overwrite) or 追記(append)
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
std::vector<std::string> data{ "aaa", "bbb", "ccc" };
save_line(data, fpass);
// test.txt
aaa
bbb
ccc

Definition at line 155 of file save.hpp.

template<class C , typename std::enable_if< container_traits< C >::exist >::type *& = enabler>
void sig::save_line ( C const &  src,
typename impl::FStreamSelector< typename container_traits< C >::value_type >::ofstream &  ofs 
)

Definition at line 208 of file file_tmp(save,read num).hpp.

template<class C , typename std::enable_if< impl::container_traits< C >::exist &&!impl::container_traits< typename impl::container_traits< C >::value_type >::exist >::type *& = enabler>
void sig::save_num ( C const &  src,
FilepassString const &  file_pass,
std::string  delimiter,
WriteMode  open_mode = WriteMode::overwrite 
)

数値列(ex:ベクトル)の保存

file_passで指定したテキストファイルに、数値が格納されたコンテナsrcの各要素を文字列として書き込む．

Parameters
src保存対象（対応コンテナ ）
file_pass保存先のパス（ファイル名含む）
delimiter数値間の区切り文字
open_mode[option] 上書き(overwrite) or 追記(append)
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
const auto list_num = std::list<double>{-1.1, -2.2, -3.3};
const auto uset_num = std::unordered_set<double>{1.1, 2.2, 3.3};
save_num(list_num, fpass, ",", WriteMode::overwrite);
save_num(uset_num, fpass, "\n", WriteMode::append);
// test.txt
-1.1,-2.2,-3.3
1.1
2.2
3.3

Definition at line 202 of file save.hpp.

template<class CC , typename std::enable_if< impl::container_traits< typename impl::container_traits< CC >::value_type >::exist >::type *& = enabler>
void sig::save_num ( CC const &  src,
FilepassString const &  file_pass,
std::string  delimiter,
WriteMode  open_mode = WriteMode::overwrite 
)

2次元配列の数値(ex:行列)を保存

Parameters
src保存対象の行列（対応コンテナ )
file_pass保存先のパス（ファイル名含む）
delimiter数値間の区切り文字
open_mode[option] 上書き(overwrite) or 追記(append)
const auto dir = modify_dirpass_tail( SIG_TO_FPSTR("./example"), true);
const auto fpass = dir + SIG_TO_FPSTR("test.txt");
const array<std::vector<int>, 3> mat = { // sig::array
{ 1, 2, 3 },
{ 4, 5, 6, 7 },
{ 8, 9 }
};
save_num(mat, fpass, ",");
// test.txt
1,2,3
4,5,6,7
8,9

Definition at line 241 of file save.hpp.

template<class C , typename std::enable_if< container_traits< C >::exist &&!container_traits< typename container_traits< C >::value_type >::exist >::type *& = enabler>
void sig::save_num ( C const &  src,
FilepassString const &  file_pass,
WriteMode  mode = WriteMode::overwrite,
std::string  delimiter = "\n" 
)

Definition at line 260 of file file_tmp(save,read num).hpp.

template<class CC , typename std::enable_if< container_traits< typename container_traits< CC >::value_type >::exist >::type *& = enabler>
void sig::save_num ( CC const &  src,
FilepassString const &  file_pass,
WriteMode  mode = WriteMode::overwrite,
std::string  delimiter1 = "\n",
std::string  delimiter2 = "\n\n" 
)

Definition at line 276 of file file_tmp(save,read num).hpp.

template<class T1 , class T2 , class TC = typename std::common_type<T1, T2>::type, class C = std::vector<TC>>
C sig::seqn ( T1  st,
T2  d,
uint  n 
)

等差数列

Parameters
st初項
d公差
n項数
Returns
結果のコンテナ（defaultはstd::vector）
auto as1 = seqn(1, 2, 5); // std::vector<int>{ 1, 3, 5, 7, 9 }
auto as2 = seqn(0, -1.1, 4); // std::vector<double>{ 0, -1.1, -2.2, -3.3 }

Definition at line 36 of file rest.hpp.

template<class C >
void sig::shuffle ( C &  container)

コンテナの要素をシャッフル

Parameters
containerシャッフル対処のコンテナ（対応コンテナ ）
std::vector<int> data{ 1, 5, 3, 3, 0, 4, 0, 1, 3 };
shuffle(data);

Definition at line 29 of file shuffle.hpp.

template<class... Cs>
void sig::shuffle ( Cs &...  containers)

複数のコンテナの同じインデックスの要素を対応させながらシャッフル

先頭から、コンテナの中で最小のインデックスまでの範囲をシャッフルする．
ex: c1[1, 2, 3, 4, 5], c2[1, 2, 3] -> c1'[3, 1, 2, 4, 5], c2'[3, 1, 2]

Parameters
containers任意個のコンテナ（対応コンテナ ）
array<double, 5> data1{ 1.1, 2.2, 3.3, 4.4, 5.5 };
std::vector<int> data2{ 1, 5, 3, -2 };
std::list<std::string> data3{ "a", "b", "c" }
shuffle(data1, data2, data3); // 各コンテナの[0]~[2]までが対応しながらシャッフルされる

Definition at line 76 of file shuffle.hpp.

auto sig::sjis_to_utf16 ( std::string const &  src) -> std::u16string
inline

ShiftJIS -> UTF-16.

Precondition
Windows環境のみ
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 238 of file convert.hpp.

auto sig::sjis_to_utf8 ( std::string const &  src) -> std::string
inline

ShiftJIS -> UTF-8.

Precondition
Windows環境のみ
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 281 of file convert.hpp.

template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class T = typename impl::sequence_container_traits<CR>::value_type, typename std::enable_if< impl::has_random_access_iter< CR >::value >::type *& = enabler>
auto sig::sort ( C &  container,
F &&  binary_op 
) -> decltype(impl::eval(std::forward<F>(binary_op), std::declval<T>(), std::declval<T>()), void())

標準ソート関数のラッパ

Parameters
containerソート対象のコンテナ（対応コンテナ ）
binary_op大小比較を行う関数オブジェクト
array<double, 3> data1{ 3.3, 1.1, -2.2 }; // sig::array
std::vector<int> data2{ 1, 5, 3, -2 };
std::list<int> data3{ 1, 5, 3, -2 };
sort(data1, std::less<double>());
data1; // { -2.2, 1.1, 3.3 }
sort(data2, std::less<int>());
data2; // { -2, 1, 3, 5 }
sort(data3, std::greater<int>());
data3; // { 5, 3, 1, -2 }

Definition at line 46 of file sort.hpp.

template<class F , class C , class CR = typename impl::remove_const_reference<C>::type, class T = typename impl::static_container_traits<CR>::value_type, class D = void, typename std::enable_if< impl::has_random_access_iter< CR >::value >::type *& = enabler>
auto sig::sort ( C &  container,
F &&  binary_op 
) -> decltype(impl::eval(std::forward<F>(binary_op), std::declval<T>(), std::declval<T>()), void())

Definition at line 61 of file sort.hpp.

template<class C , class F , class T = typename impl::container_traits<typename impl::remove_const_reference<C>::type>::value_type>
auto sig::sort_with_index ( C &&  container,
F &&  binary_op 
)

ソート前の位置を保持してソート

ex: [30, 50, -10, 0] -> ([-10, 0, 30, 50], [2, 3, 0, 1])

Parameters
containerソート対象のコンテナ（対応コンテナ ）
binary_op大小比較を行う関数オブジェクト
Returns
std::tuple<(ソート後のコンテナ), (ソート前のindexを記録したコンテナ)>
const std::vector<int> cdata1{ 30, 50, -10, 0 };
auto swi1 = sort_with_index(cdata1, std::less<int>());
auto sorted1 = std::get<0>(swi1); // { -10, 0, 30, 50 }
auto original_index1 = std::get<1>(swi1); // { 2, 3, 0, 1 }
class TestInt{
std::vector<int> v;
bool emp;
public:
TestInt() : v(), emp(true){}
TestInt(int i) : v(1, i), emp(false){}
TestInt(TestInt const& s) : v(s.v), emp(false){}
TestInt(TestInt&& s) : v(std::move(s.v)), emp(false){ s.emp = true; }
TestInt& operator=(TestInt const& s){ v = s.v; emp = false; return *this; }
TestInt& operator=(TestInt&& s){ v = std::move(s.v); emp = false; s.emp = true; return *this; }
bool empty() const{ return emp; }
int value() const{ return emp ? -1 : v[0]; }
};
array<TestInt, 4> data2{ 30, 50, -10, 0 };
auto swi2 = sort_with_index(std::move(data2), [](TestInt const& l, TestInt const& r){ return l.value() > r.value(); });
auto sorted1 = std::get<0>(swi2); // { 50, 30, 0, -10 }
auto original_index1 = std::get<1>(swi2); // { 1, 0, 3, 2 }
assert(data2[0].empty() && data2[8].empty()); // moved

Definition at line 131 of file sort.hpp.

template<template< class T_, class=std::allocator< T_ >> class CSeq = std::vector, class S = std::string, class TS = impl::string_t<S>>
auto sig::split ( S const &  src,
impl::string_t< S > const &  delimiter 
) -> CSeq<TS>

文字列(src)をある文字列(delimiter)を目印に分割する

Template Parameters
CSeqreturnされるシーケンスコンテナの種類
Parameters
src分割対象の文字列
delimiter分割の目印となる文字列
Returns
分割後の文字列が格納されたシーケンスコンテナ
auto src = " one,2, 参 ";
auto spl = split(src, ","); // vector<string>{" one", "2", " 参 "}

Definition at line 40 of file manipulate.hpp.

template<template< class T_, class=std::allocator< T_ >> class CSeq = std::vector>
auto sig::split ( char const *const  src,
char const *const  delimiter 
) -> CSeq<std::string>
See also
split(S const& src, impl::string_t<S> const& delimiter)

Definition at line 84 of file manipulate.hpp.

template<template< class T_, class=std::allocator< T_ >> class CSeq = std::vector>
auto sig::split ( wchar_t const *const  src,
wchar_t const *const  delimiter 
) -> CSeq<std::wstring>
See also
split(S const& src, impl::string_t<S> const& delimiter)

Definition at line 96 of file manipulate.hpp.

template<class C , typename std::enable_if< std::is_floating_point< typename impl::container_traits< C >::value_type >::value >::type *& = enabler>
bool sig::standardize ( C &  data)

標準化(Standardization)

正規分布N(0, 1)になるように正規化
standardize(C const& data, int dummy = 0)ではなくこちらが呼び出されているかを確認するには、返り値をboolで受けるようにする

Parameters
data標準化を行いたい値集合（対応コンテナ ）．要素型は浮動小数点型であることが条件
Returns
なし
array<double, 5> ar{ -3, -1, 0, 1, 3 }; // sig::array
bool ck = standardize(ar);
ar; // { -0.75, -0.25, 0, 0.25, 0.75 }

Definition at line 331 of file basic_statistics.hpp.

template<class R = double, class C = void>
auto sig::standardize ( C const &  data,
int  dummy = 0 
) -> typename impl::container_traits<C>::template rebind<R>

標準化(Standardization)

正規分布N(0, 1)になるように正規化． standardize(C& data)ではなく明示的にこちらを呼び出す場合は、第2引数を指定

Parameters
data標準化を行いたい値集合（対応コンテナ ）
Returns
標準化を行った結果
const array<int, 5> ar1{ -3, -1, 0, 1, 3 }; // sig::array
array<double, 5> ar2{ 0, 1, 2, 3, 4 }; // sig::array
auto stnd1 = standardize(ar1); // { -0.75, -0.25, 0, 0.25, 0.75}
// 第2引数はダミー(ar2はconstでないため、オーバーロード解決でこの関数を呼び出すために必要)
auto stnd2 = standardize(ar2, 0); // { -1, -0.5, 0, 0.5, 1 }

Definition at line 363 of file basic_statistics.hpp.

auto sig::str_to_wstr ( std::string const &  src) -> std::wstring
inline

マルチバイト文字 -> ワイド文字

ex: Windows環境では Shift-JIS -> UTF-16

Parameters
src変換対象の文字列
Returns
変換後の文字列
const std::string str = "aあ亜";
std::wstring wstr = str_to_wstr(str);

Definition at line 116 of file convert.hpp.

template<class C , class R = typename impl::container_traits<C>::template rebind<std::wstring>, typename std::enable_if< std::is_same< typename impl::container_traits< C >::value_type, std::string >::value >::type *& = enabler>
auto sig::str_to_wstr ( C const &  src) -> R

マルチバイト文字 -> ワイド文字

コンテナの全要素をまとめて変換 ex: Windows環境では Shift-JIS -> UTF-16

Parameters
src変換対象の文字列が格納されたコンテナ（対応コンテナ ）
Returns
変換後の文字列が格納されたコンテナ
See also
str_to_wstr(std::string const& src)
const std::vector<std::string> svec{"a", "あ", "亜");
auto wsvec = str_to_wstr(svec); // std::vector<std::wstring>

Definition at line 154 of file convert.hpp.

template<class R = void, class C = void>
auto sig::sum ( C const &  data) -> typename impl::SameIf<R, void, typename impl::container_traits<C>::value_type, R>::type

総和

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
data総和を求めたい値集合（対応コンテナ ）
Returns
計算結果
std::vector<int> vec{1,2,3};
std::set<double> set{1.1, 2.2, 3.3};
int s1 = sum(vec); // 6
double s2 = sum(set); // 6.6

Definition at line 35 of file basic_statistics.hpp.

template<class R = void, class C = void, class Pred = void>
auto sig::sum ( C const &  data,
Pred const &  access_func 
) -> typename impl::SameIf<R, void, decltype(impl::eval(access_func, std::declval<typename impl::container_traits<C>::value_type>())), R>::type

総和

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
data総和を求めたい値集合（対応コンテナ ）
access_funcコンテナの要素にアクセスし、そのオブジェクトから値を取得する関数
Returns
計算結果
array<std::tuple<int, int>, 2> ar{std::make_tuple(1, -1), std::make_tuple(2, -2)};
int s = sum(ar, [](std::tuple<int, int> const& e){ return std::get<1>(e); }); // -3

Definition at line 59 of file basic_statistics.hpp.

template<class R = void, class CC = void>
auto sig::sum_col ( CC const &  matrix,
uint  index 
)

行列の指定列の総和

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
matrix行列（ランダムアクセス可能な2次元コンテナ）
index総和を求めたい列番号
Returns
計算結果
array<array<int, 3>, 2> mat{ { 1, 2, 3 }, { 4, 5, 6 } }; // sig::array
int sc = sum_col(mat, 1); // 7

Definition at line 106 of file basic_statistics.hpp.

template<class R = void, class CC = void>
auto sig::sum_row ( CC const &  matrix,
uint  index 
)

行列の指定行の総和

Template Parameters
R戻り値型（桁あふれの可能性がある場合には明示的に指定する）
Parameters
matrix行列（ランダムアクセス可能な2次元コンテナ）
index総和を求めたい行番号
Returns
計算結果
array<array<int, 3>, 2> mat{ { 1, 2, 3 }, { 4, 5, 6 } }; // sig::array
int sr = sum_row(mat, 1); // 15

Definition at line 84 of file basic_statistics.hpp.

template<class C , class CR = typename impl::remove_const_reference<C>::type>
auto sig::take ( uint  n,
C &&  list 
) -> CR

コンテナの先頭からn個の要素を取り出す

uint -> [a] -> [a]

Parameters
n先頭から順に取り出す要素の個数
listソースとなるコンテナ（対応コンテナ ）
Returns
結果のコンテナ（listと同じ種類）
const array<int, 4> data1{ 1, 2, 3, 4 }; // sig::array
std::vector<int> data2{ 1, -3, 5, 2, 10 };
auto t1 = take(2, data1); // array<int, 4>{ 1, 2 }
auto t2 = take(3, data2); // std::vector<int> data2{ 1, -3, 5 }

Definition at line 225 of file list_deal.hpp.

template<class CC , class T = typename impl::container_traits<typename impl::container_traits<CC>::value_type>::value_type>
auto sig::to_matrix_ublas ( CC const &  mat) -> matrix_u<T>

STLのvectorの2次元配列 から ublas::matrix<T> へ変換

Definition at line 174 of file ublas.hpp.

template<class C , class T = typename impl::container_traits<C>::value_type>
auto sig::to_vector_ublas ( C const &  vec) -> vector_u<T>

STLのvector から ublas::vector<T> へ変換

Definition at line 161 of file ublas.hpp.

template<uint Index, class CT , class T = typename std::tuple_element<Index, typename impl::container_traits<typename impl::remove_const_reference<CT>::type>::value_type>::type, class R = std::vector<T>>
auto sig::unzip ( CT &&  list_tuple) -> R

タプルのコンテナから、指定したindexのコンテナを取り出す

[(a, b, ...)] -> [a0]

Template Parameters
Index取り出すインデックス
Parameters
list_tupleデータが格納されたタプルのコンテナ [(a, b, ...)]（対応コンテナ ）
Returns
結果のコンテナ（コンテナはc_tupleと同じ種類）
const array<std::tuple<int, std::string>, 3> data{ // sig::array
std::make_tuple(1, "a"),
std::make_tuple(2, "b"),
std::make_tuple(3, "c")
};
auto uz1 = unzip<0>(data); // array<int, 3>{ 1, 2, 3 }
auto uz2 = unzip<1>(data); // array<std::string, 3>{ "a", "b", "c" }

Definition at line 85 of file zip.hpp.

template<class CT >
auto sig::unzip ( CT &&  c_tuple)

タプルのコンテナから、コンテナのタプルを作る

[(a, b, ...)] -> ([a], [b], ...)

Parameters
c_tupleデータが格納されたタプルのコンテナ [(a, b, ...)]（対応コンテナ ）
Returns
結果のコンテナを持つタプル（コンテナはc_tupleと同じ種類）
const array<std::tuple<int, std::string>, 3> data{ // sig::array
std::make_tuple(1, "a"),
std::make_tuple(2, "b"),
std::make_tuple(3, "c")
};
auto uz = unzip(data); // std::tuple< array<int, 3>, array<std::string, 3> >
auto e1 = std::get<0>(uz); // array<int, 3>{ 1, 2, 3 }
auto e2 = std::get<1>(uz); // array<std::string, 3>{ "a", "b", "c" }

Definition at line 139 of file zip.hpp.

auto sig::utf16_to_sjis ( std::u16string const &  src) -> std::string
inline

UTF-16 -> ShiftJIS.

Precondition
Windows環境のみ
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 258 of file convert.hpp.

auto sig::utf16_to_utf8 ( std::u16string const &  src) -> std::string
inline

UTF-16 -> UTF-8.

Precondition
<codecvt>が必要
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 190 of file convert.hpp.

auto sig::utf32_to_utf8 ( std::u32string const &  src) -> std::string
inline

UTF-32 -> UTF-8.

Precondition
<codecvt>が必要
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 220 of file convert.hpp.

auto sig::utf8_to_sjis ( std::string const &  src) -> std::string
inline

UTF-8 -> ShiftJIS.

Precondition
Windows環境のみ
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 294 of file convert.hpp.

auto sig::utf8_to_utf16 ( std::string const &  src) -> std::u16string
inline

UTF-8 -> UTF-16.

Precondition
<codecvt>が必要
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 175 of file convert.hpp.

auto sig::utf8_to_utf32 ( std::string const &  src) -> std::u32string
inline

UTF-8 -> UTF-32.

Precondition
<codecvt>が必要
Parameters
src変換対象の文字列
Returns
変換後の文字列

Definition at line 205 of file convert.hpp.

template<class F , class C1 , class... Cs>
auto sig::variadicZipWith ( F &&  func,
C1 &&  list1,
Cs &&...  lists 
)

n引数高階関数

(b -> c -> ... -> a) -> [b] -> [c] -> ... -> [a]

Definition at line 23 of file high_order.hpp.

template<class C >
double sig::variance ( C const &  data)

分散

Parameters
data分散を求めたい値集合（対応コンテナ ）
Returns
計算結果
std::vector<int> vec{1,2,3,4};
double var = variance(vec); // 1.25

Definition at line 241 of file basic_statistics.hpp.

auto sig::wstr_to_str ( std::wstring const &  src) -> std::string
inline

ワイド文字 -> マルチバイト文字

ex: Windows環境では UTF-16 -> Shift-JIS

Parameters
src変換対象の文字列
Returns
変換後の文字列
const std::wstring wstr(L"aあ亜");
std::string str = wstr_to_str(wstr);

Definition at line 50 of file convert.hpp.

template<class C , class R = typename impl::container_traits<C>::template rebind<std::string>, typename std::enable_if< std::is_same< typename impl::container_traits< C >::value_type, std::wstring >::value >::type *& = enabler>
auto sig::wstr_to_str ( C const &  src) -> R

ワイド文字 -> マルチバイト文字

コンテナの全要素をまとめて変換 ex: Windows環境では UTF-16 -> Shift-JIS

Parameters
src変換対象の文字列集合が格納されたコンテナ（対応コンテナ ）
Returns
変換後の文字列集合が格納されたコンテナ
See also
wstr_to_str(std::wstring const& src)
const std::vector<std::wstring> wsvec{L"a", L"あ", L"亜");
auto svec = wstr_to_str(wsvec); // std::vector<std::string>

Definition at line 90 of file convert.hpp.

template<class B1 , class B2 >
bool sig::Xor ( B1 &&  a,
B2 &&  b 
)

xor

Parameters
cond,condsbool変数 または operator boolが定義されたオブジェクト
Returns
xorの結果
static_assert(!Xor(true, true), "");
static_assert(Xor(true, false), "");
static_assert(Xor(false, true), "");
static_assert(!Xor(false, false), "");

Definition at line 92 of file helper_modules.hpp.

template<class... Cs>
auto sig::zip ( Cs &&...  lists)

複数のコンテナから、タプルのコンテナを作る

[a] -> [b] -> ... -> [(a, b, ...)]
listsのいずれかの末尾に到達するまでタプルが作られる

Parameters
lists...データが格納された複数のコンテナ [a],[b],...（対応コンテナ ）
Returns
処理結果のコンテナ [(a, b, ...)]（コンテナはlistsの[a]と同じ種類）
const array<int, 4> data1{ 1, 2, 3, 4 }; // sig::array
const std::vector<int> data2{ 1, -3, 5, 2, 10 };
const std::list<double> data3{ 1.1, -2.2, 3.3 };
const std::set<std::string> data4{ "a", "aa", "aaa" };
auto z = zip(data1, data2, data3, data4); // array< std::tuple<int, int, double, std::string>, 4>
uint size = z.size(); // 3
auto e1 = z[1]; // std::tuple<int, int, double, std::string>{ 2, -3, -2.2, "aa" }

Definition at line 43 of file zip.hpp.

template<class F , class C1 , class C2 >
auto sig::zipWith ( F &&  func,
C1 &&  list1,
C2 &&  list2 
)

2引数高階関数

(a -> b -> c) -> [a] -> [b] -> [c]
2つのコンテナのindexが対応する各要素に関数を適用し、結果を新たなコンテナに格納する

Parameters
func関数 (a -> b -> c)
list1データが格納されたコンテナ [a]（対応コンテナ ）
list2データが格納されたコンテナ [b]（対応コンテナ ）
Returns
処理結果のコンテナ [c]（コンテナはlist1と同じ種類）
const array<int, 3> data1{ 1, -3, 5 }; // sig::array
const std::set<double> data2{ -2.2, 0 , 1.1, 3.3 };
auto r = zipWith([](int a, double b){ return (a + b) / 2; }, data1, data2);
r; // array<double, 3>{ -6, -1.5, 3.05 }

Definition at line 88 of file high_order.hpp.

Variable Documentation

const AbsoluteError sig::absolute_error

Definition at line 33 of file convergence.hpp.

const BinaryDistance sig::binary_distance

バイナリ距離を求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点間の距離
const array<uint, 4> dot1{ 1, 1, 0, 0 }; // sig::array
const std::list<bool> dot2{ true, false, true, true };
double d = binary_distance(dot1, dot2);
d; // 0.75

Definition at line 54 of file binary_distance.hpp.

const CanberraDistance sig::canberra_distance

キャンベラ距離を求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点間の距離
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double d = canberra_distance(dot1, dot2);
d; // 22 / 9.0

Definition at line 47 of file canberra_distance.hpp.

const CosineSimilarity sig::cosine_similarity

コサイン類似度を求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点間のコサイン距離
Postcondition
値域：[-1, 1]
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double d = canberra_distance(dot1, dot2);
d; // 0.81649...

Definition at line 49 of file cosine_similarity.hpp.

void* sig::enabler
const EuclideanDistance sig::euclidean_distance

ユークリッド距離を求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点間の距離
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double d = euclidean_distance(dot1, dot2);
d; // 7.5

Definition at line 81 of file minkowski_distance.hpp.

const JS_Divergence sig::js_divergence

JS情報量を求める関数（関数オブジェクト）

Parameters
dist1確率分布1（対応コンテナ ）
dist2確率分布2（対応コンテナ ）
Precondition
dist1, dist2 の各要素は0以上の値 かつ 総和が 1
Returns
確率分布間の非類似度（値はMaybe で返される）
Postcondition
値域：[0, ∞)
const array<double, 5> dist1{ 0.2, 0.1, 0, 0.4, 0.3 }; // sig::array
const std::list<double> dist2{ 0.1, 0.3, 0.1, 0.4, 0.1 };
auto m_js12 = js_divergence(dist1, dist2)); // js12 :: Maybe<double>
auto m_js21 = js_divergence(dist2, dist1)); // js21 :: Maybe<double>
double js12 = fromJust(m_js12); // 0.137744...
double js21 = *m_js21; // 0.137744...

Definition at line 65 of file JS_divergence.hpp.

const KL_Divergence sig::kl_divergence

KL情報量を求める関数（関数オブジェクト）

Parameters
dist1確率分布1（対応コンテナ ）
dist2確率分布2（対応コンテナ ）
Precondition
dist1の各要素は0以上の値 かつ dist2の各要素は正の値 かつ 総和が 1
Returns
確率分布間の非類似度（値はMaybe で返される）
Postcondition
値域：[0, ∞)
const array<double, 5> dist1{ 0.2, 0.1, 0, 0.4, 0.3 }; // sig::array
const std::list<double> dist2{ 0.1, 0.3, 0.1, 0.4, 0.1 };
auto m_kl12 = kl_divergence(dist1, dist2)); // kl12 :: Maybe<double>
// auto m_kl21 = kl_divergence(dist2, dist1)); // error because dist1 has element whose value is 0
double kl12 = fromJust(m_kl12); // 0.51699...

Definition at line 62 of file KL_divergence.hpp.

const ManhattanDistance sig::manhattan_distance

マンハッタン距離を求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点間の距離
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double d = manhattan_distance(dot1, dot2);
d; // 5

Definition at line 62 of file minkowski_distance.hpp.

const Norm<1> sig::norm_L1

L1ノルムを求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2[option] データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点のノルム（vec2を指定時はデータ点間のノルム）
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double n = norm_L1(data1);
double nn = norm_L1(dot1, dot2);
n; // 7
nn; // 5

Definition at line 63 of file norm.hpp.

const Norm<2> sig::norm_L2

L2ノルムを求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2[option] データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点のノルム（vec2を指定時はデータ点間のノルム）
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double n = norm_L2(data1);
double nn = norm_L2(dot1, dot2);
n; // 3.87298...
nn; // 2.73861...

Definition at line 82 of file norm.hpp.

const MaxNorm sig::norm_max

最大ノルムを求める関数（関数オブジェクト）

Parameters
vec1データ点1の座標ベクトル（対応コンテナ ）
vec2[option] データ点2の座標ベクトル（対応コンテナ ）
Returns
データ点のノルム（vec2を指定時はデータ点間のノルム）
const array<uint, 5> dot1{ -1, 0, 1, 2, 3 }; // sig::array
const std::list<bool> dot2{ 1, 1.5, 2, 2.5, 3 };
double n = norm_max(data1);
double nn = norm_max(dot1, dot2);
n; // 3
nn; // 2

Definition at line 125 of file norm.hpp.

const RelativeError sig::relative_error

Definition at line 48 of file convergence.hpp.