モジュール
	Affine行列クラス

	ポータブルテンプレート行列クラスライブラリ

ファイル
ファイル	Affine.h
	2/3次元アフィン行列

ファイル	TinyMat.h
	2x2, 3x3行列の定義

ファイル	TinyVec.h
	2,3,4次元のベクトルの定義

ファイル	TMatrix.h
	テンプレートによるN×M行列型の定義.

ファイル	TMatrixUtility.h
	行列初期化ユーティリティー．

ファイル	TQuaternion.h
	クォータニオンクラスの定義

ファイル	TVector.h
	C++ の template 機能を生かしたベクトルライブラリ．メモリと管理情報(ベクトルのサイズなど)の持ち方で3種ある。

構成
class	TMatrix2< T >
	2x2行列クラス. [詳細]

class	TMatrix3< T >
	3x3行列クラス. [詳細]

class	TVecDesc< EXP, T >

class	TVec2< T >
	2次元ベクトルクラス [詳細]

class	TVec3< T >
	3次元ベクトルクラス. [詳細]

class	TVec4< T >
	4次元ベクトルクラス. [詳細]

class	TVec6< T >
	6次元ベクトルクラス. [詳細]

class	TQuaternion< ET >
	Quaternion/4元数．3x3行列の代わりに回転を表すために使える． 4変数で済む．補間や微分・積分がやりやすい． TVec3との掛け算は，回転変換でオーバーロードされている． [詳細]

class	TPose< ET >
	姿勢．位置と向きを表すクラス． TQuaternion と TVec3 で向きと位置を表す． TAffineの代わりに使える． [詳細]

class	VectorDesc< EXP, RET, E, Z >

class	TVectorDesc< STR, EXP, RET, E, Z >

class	VectorImp< D >
	ベクトルの演算などの実装 [詳細]

class	TVectorBase< N, D >
	次元をテンプレートで持つベクトルの基本型 [詳細]

class	TVectorSlice< SZ, STR, OD >

class	TSubVector< SZ, OD >

class	EVectorSlice< D >

class	ConstEVectorSlice< D >

class	TSubVectorDim< SOFF, SDIM >
	部分ベクトル型作成のためのユーティリティークラス. [詳細]

class	TVector< N, T >
	ベクトル型. [詳細]

class	VVector< T >
	ベクトル型. [詳細]

class	ConstEVector< T >
	ベクトル型. [詳細]

class	EVector< T >

マクロ定義
#define	TYPENAME typename

#define	DEF_VECTOR_BASIC_MEMBER(THIS)
	ベクトル型派生クラスに必要なメンバの定義. [詳細]

#define	DEF_TVECTOR_BASIC_MEMBER(THIS)

型定義
typedef TMatrix2< float >	Matrix2f
	float版2×2行列．

typedef TMatrix2< double >	Matrix2d
	double版2×2行列．

typedef TMatrix3< float >	Matrix3f
	float版3×3行列．

typedef TMatrix3< double >	Matrix3d
	double版3×3行列．

typedef TVec2< int >	Vec2i
	int版2次元ベクトル

typedef TVec2< float >	Vec2f
	float版2次元ベクトル

typedef TVec2< double >	Vec2d
	double版2次元ベクトル

typedef TVec3< int >	Vec3i
	int版3次元ベクトル

typedef TVec3< float >	Vec3f
	float版3次元ベクトル

typedef TVec3< double >	Vec3d
	double版3次元ベクトル

typedef TVec4< int >	Vec4i
	int版4次元ベクトル

typedef TVec4< float >	Vec4f
	float版4次元ベクトル

typedef TVec4< double >	Vec4d
	double版4次元ベクトル

typedef TVec6< int >	Vec6i
	int版6次元ベクトル

typedef TVec6< float >	Vec6f
	float版6次元ベクトル

typedef TVec6< double >	Vec6d
	double版6次元ベクトル

typedef TQuaternion< float >	Quaternionf
	float版TQuaternion.

typedef TQuaternion< double >	Quaterniond
	double版TQuaternion.

typedef TPose< float >	Posef
	float版TPose.

typedef TPose< double >	Posed
	double版TPose.

関数
template<class T >
bool	IsUnitary (TMatrix3< T > r)

void	getAxisMap2D (int &x, int &y, int axis)

template<class MD , class AD >
void	init_rot (TMatrixBase< 2, 2, MD > &m, const TVectorBase< 2, AD > &a, char axis)
	x/y軸を指定して2×2行列を回転行列に初期化

template<class D >
void	init_rot (TMatrixBase< 2, 2, D > &m, TYPENAME D::element_type th)
	2×2行列を回転行列に初期化

void	getAxisMap3D (int &x, int &y, int &z, int axis)

template<class MD , class AD , class BD >
void	init_rot (TMatrixBase< 3, 3, MD > &m, const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b, char axis)
	axis軸, axis++軸を指定して3×3行列を回転行列に初期化

template<class MD >
void	init_rot (TMatrixBase< 3, 3, MD > &m, TYPENAME MD::element_type th, char axis)
	3×3行列をx/y/z軸まわり回転行列に初期化

template<class MD , class AD >
void	init_rot (TMatrixBase< 3, 3, MD > &m, TYPENAME MD::element_type th, const TVectorBase< 3, AD > &axis)
	3×3行列を任意軸まわり回転行列に初期化 [詳細]

template<class MD , class QD >
void	init_rot (TMatrixBase< 3, 3, MD > &m, const TVectorBase< 4, QD > &q)
	3×3行列をクォータニオンから任意軸まわり回転行列に初期化

template<class D >
void	init_unitize (TMatrixBase< 2, 2, D > &m)
	2×2行列を単位行列に初期化

template<class D >
void	init_unitize (TMatrixBase< 3, 3, D > &m)
	3×3行列を単位行列に初期化

template<class D >
void	init_unitize (TMatrixBase< 4, 4, D > &m)
	4×4行列を単位行列に初期化

template<class M >
void	init_unitize (MatrixImp< M > &m)
	N×N行列を単位行列に初期化

template<class MD , class D >
void	init_cross (TMatrixBase< 3, 3, MD > &m, const TVectorBase< 3, D > &v)
	3×3行列をベクトルの外積計算になるように初期化(m*b == v^b).

template<class D , class BP , class BT >
void	init_look_at (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, BP > &pos, const TVectorBase< 3, BT > &diry)
	4×4行列をある点を注視する視点行列に初期化する．

template<class D , class BZ , class BY >
void	init_look_at_gl (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, BZ > &pos, const TVectorBase< 3, BY > &diry)
	4×4行列をある点を注視する視点行列に初期化する．

template<class D , class SD , class ZD >
void	init_projection_gl (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, SD > &screen_, const TVectorBase< 2, ZD > &size_, TYPENAME D::element_type front=1.0f, TYPENAME D::element_type back=10000.0f)

template<class D , class SD , class ZD >
void	init_projection_d3d (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, SD > &screen_, const TVectorBase< 2, ZD > &size_, TYPENAME D::element_type front=1.0f, TYPENAME D::element_type back=10000.0f)

template<class D , class SD , class ZD >
void	init_ortho_gl (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, SD > &screen_, const TVectorBase< 2, ZD > &size_, TYPENAME D::element_type front=1.0f, TYPENAME D::element_type back=10000.0f)

template<class QD , class T , class AD >
void	init_quaternion (TVectorBase< 4, QD > &q, T angle, const TVectorBase< 3, AD > &axis)
	4行ベクトルを回転をあらわすクォータニオンとして初期化

template<class QD , class AD >
void	init_quaternion (TVectorBase< 4, QD > &q, const TVectorBase< 3, AD > &rot)
	4行ベクトルを回転をあらわすクォータニオンとして初期化

template<class QD , class T >
void	init_quaternion (TVectorBase< 4, QD > &q, T angle, char axis)
	4行ベクトルを回転をあらわすクォータニオンとして初期化

template<class QD , class MD >
void	init_quaternion (TVectorBase< 4, QD > &qt, const TMatrixBase< 3, 3, MD > &m)
	4行ベクトルを回転をあらわすクォータニオンとして初期化

template<class A , class B >
TQuaternion< A >	operator* (const TQuaternion< A > &q1, const TQuaternion< B > &q2)
	TQuaternion 同士の掛け算．回転変換としては，合成になる．

template<class ET , class BD >
TYPENAME BD::ret_type	operator* (const TQuaternion< ET > &q, const PTM::TVectorBase< 3, BD > &v)
	TQuaternionでベクトルを回転． Quaternion * vector * Quaternion^{*} と同じ．

template<class ET , class BD >
TYPENAME BD::ret_type	operator* (const TQuaternion< ET > &q, const PTM::TMatrixBase< 3, 3, BD > &m)
	TQuaternionで行列を回転． TQuaternion * (ex,ey,ez) * TQuaternion.conjugated() と同じ．

template<class T1 , class T2 >
T1	dot (const TQuaternion< T1 > &q1, const TQuaternion< T2 > &q2)
	TQuaternion の内積．

template<class ET , class BD >
TQuaternion< ET >	mult (const TQuaternion< ET > &q, const PTM::TVectorBase< 3, BD > &v)
	回転操作をせず，普通にQuaternionとベクトルの積を求める

template<class BD , class ET >
TQuaternion< ET >	mult (const PTM::TVectorBase< 3, BD > &v, const TQuaternion< ET > &q)
	回転操作をせず，普通にベクトルとQuaternionの積を求める

template<class T1 , class T2 >
TQuaternion< T1 >	interpolate (T1 t, const TQuaternion< T1 > &q1, const TQuaternion< T2 > &q2)

template<class EP , class EV >
TVec3< EV >	operator* (const TPose< EP > &p, const TVec3< EV > &v)

template<class EA , class EB >
TPose< EA >	operator* (const TPose< EA > &a, const TPose< EB > &b)

template<class EA , class EB >
TPose< EA >	interpolate (EA t, const TPose< EA > &p0, const TPose< EB > &p1)
	Poseの補間

template<class AD , class BD >
TYPENAME AD::ret_type	operator+ (const VectorImp< AD > &a, const VectorImp< BD > &b)
	ベクトルの和(return a + b). [詳細]

template<class AD , class BD >
TYPENAME AD::ret_type	operator- (const VectorImp< AD > &a, const VectorImp< BD > &b)
	ベクトルの差(return a - b). [詳細]

template<class BD >
TYPENAME BD::ret_type	operator* (const TYPENAME BD::element_type &a, const VectorImp< BD > &b)
	スカラーとベクトルの積(return a * b). [詳細]

template<class BD >
TYPENAME BD::ret_type	operator* (const VectorImp< BD > &a, const TYPENAME BD::element_type &b)
	スカラーとベクトルの積(return a * b). [詳細]

template<class AD , class BD >
AD::element_type	operator* (const VectorImp< AD > &a, const VectorImp< BD > &b)
	ベクトルの内積(return a * b). [詳細]

template<class AD , class BD >
bool	operator== (const VectorImp< AD > &a, const VectorImp< BD > &b)
	比較(return a == b). [詳細]

template<class AD , class BD >
bool	operator!= (const VectorImp< AD > &a, const VectorImp< BD > &b)
	比較(return a != b). [詳細]

template<class BD >
std::ostream &	operator<< (std::ostream &os, const VectorImp< BD > &v)
	ストリームに書式付で出力する.

template<class BD >
std::istream &	operator>> (std::istream &is, VectorImp< BD > &v)
	ストリームから書式付で入力する.

template<class AD , class BD >
AD::element_type	cross (const TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)
	2次元ベクトルの外積(return a x b). [詳細]

template<class AD , class BD >
AD::element_type	operator% (const TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)

template<class AD , class BD >
AD::element_type	operator^ (const TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)

template<class AD , class BD >
TYPENAME AD::ret_type	cross (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
	3次元ベクトルの外積(return a x b). [詳細]

template<class AD , class BD >
TYPENAME AD::ret_type	operator% (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)

template<class AD , class BD >
TYPENAME AD::ret_type	operator^ (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)

template<class AD , class BD >
TYPENAME AD::ret_type	interpolate (TYPENAME AD::element_type &t, const VectorImp< AD > &a, const VectorImp< BD > &b)
	補間 [詳細]

演算.
template<class D >
void	clear (VectorImp< D > &a, const TYPENAME D::element_type v=D::zero(0))
	ベクトルの要素を全てvにする. [詳細]

template<class AD , class BD >
void	assign (VectorImp< AD > &a, const VectorImp< BD > &b)
	代入(a = b). [詳細]

template<class AD , class BD >
void	assign (TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)
	代入(a = b) 2要素専用

template<class AD , class BD >
void	assign (TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
	代入(a = b) 3要素専用

template<class AD , class BD >
void	assign (TVectorBase< 4, AD > &a, const TVectorBase< 4, BD > &b)
	代入(a = b) 4要素専用

template<class AD >
void	assign (VectorImp< AD > &a, const TYPENAME AD::element_type *b)
	代入(a = b). [詳細]

template<class AD , class BD >
void	add (VectorImp< AD > &a, const VectorImp< BD > &b)
	加算(a += b). [詳細]

template<class AD , class BD >
void	sub (VectorImp< AD > &a, const VectorImp< BD > &b)
	減算(a -= b). [詳細]

template<class AD >
void	multi (VectorImp< AD > &a, const TYPENAME AD::element_type &b)
	定数倍(this = b). [詳細]

template<class AD , class BD >
void	multi_each (VectorImp< AD > &a, const VectorImp< BD > &b)
	定数倍(this = b). [詳細]

template<class AD >
void	div (VectorImp< AD > &a, const TYPENAME AD::element_type &b)
	定数分の１(*this /= b). [詳細]

template<class AD , class BD >
TYPENAME AD::element_type	dot (const VectorImp< AD > &a, const VectorImp< BD > &b)
	内積(return this b). [詳細]

template<class AD , class BD >
TYPENAME AD::element_type	dot (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)

template<class AD , class BD >
bool	equal (const VectorImp< AD > &a, const VectorImp< BD > &b)
	比較(return *this == b). [詳細]

template<class AD , class BD >
void	element_min_impl (VectorImp< AD > &a, const VectorImp< BD > &b)
	要素ごとの最小値(min(*this, b)). [詳細]

template<class AD , class BD >
TYPENAME AD::ret_type	element_min (const VectorImp< AD > &a, const VectorImp< BD > &b)

template<class AD , class BD >
void	element_max_impl (VectorImp< AD > &a, const VectorImp< BD > &b)
	要素ごとの最大値(max(*this, b)). [詳細]

template<class AD , class BD >
TYPENAME AD::ret_type	element_max (const VectorImp< AD > &a, const VectorImp< BD > &b)

template<class AD , class BD , class ED >
void	clip (const VectorImp< AD > &a, const VectorImp< BD > &b, const VectorImp< ED > &e)
	クリッピングする(bとeを頂点とする矩形内に収まるようにする).

説明

マクロ定義

#define DEF_TVECTOR_BASIC_MEMBER ( THIS )

値:

DEF_VECTOR_BASIC_MEMBER(THIS)                                           \
    /*  ベクトル b による初期化       */                                      \
    template <class D>                                                      \
    THIS(const PTM::VectorImp<D>& b){                                       \
        this->init_buffer(); this->assign(b);}                              \
    /*  要素数が等しい配列 p による初期化  */                              \
    THIS(const element_type* p){                                            \
        this->assign(p);                                                            \
    }                                                                       \
    /*  デフォルトコンストラクタ    */                                      \
    THIS(){ this->init_buffer(); this->set_default(); }         \

#define DEF_VECTOR_BASIC_MEMBER ( THIS )

値:

typedef THIS this_type;         /*  このクラスの型を定義しておく. */  \
    typedef TYPENAME desc::element_type element_type;                       \
    typedef TYPENAME desc::ret_type ret_type;                               \
    /*  コピーコンストラクタ  */                                          \
    THIS& operator =(const THIS& b){                                        \
        this->exp().assign(b); return *this;                                            \
    }                                                                       \
    /*  ベクトル b を代入  */                                              \
    template <class D>                                                      \
    THIS& operator =(const PTM::VectorImp<D>& b){                           \
        this->exp().assign(b); return *this;                                        \
    }                                                                       \
    /*  ベクトル b を加算  */                                              \
    template <class D>                                                      \
    THIS& operator +=(const PTM::VectorImp<D>& b){                          \
        this->exp().add(b); return *this;                                           \
    }                                                                       \
    /*  ベクトル b を減算  */                                              \
    template <class D>                                                      \
    THIS& operator -=(const PTM::VectorImp<D>& b){                          \
        this->exp().sub(b); return *this;                                           \
    }                                                                       \
    /*  要素数が等しい配列 p の代入 */                                      \
    THIS& operator =(const element_type* p){                                \
        this->exp().assign(p);                                          \
        return *this;                                                       \
    }                                                                       \

派生クラスを作るたびに，このマクロを使ってメンバを作る. デフォルトコンストラクタ，同じサイズのベクトルによる初期化・代入などが定義される．

引数

THIS	新たに宣言する派生クラスの型名.

参照: TVector

関数

void PTM::add	(	VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル.
b	同じサイズのベクトル.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::add().

void PTM::assign	(	VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

b	同じサイズのベクトル.

参照先 VectorImp< D >::item(), VectorImp< D >::resize(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::assign(), と MyApp::HeatConductionStep().

void PTM::assign	(	VectorImp< AD > &	a,
		const TYPENAME AD::element_type *	b
	)

引数

a	ベクトル.
b	同じサイズのベクトル.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

void PTM::clear	(	VectorImp< D > &	a,
		const TYPENAME D::element_type	v = `D::zero(0)`
	)

引数

v 要素型の値.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::clear().

AD::element_type PTM::cross	(	const TVectorBase< 2, AD > &	a,
		const TVectorBase< 2, BD > &	b
	)

引数

a	2次元ベクトル型
b	2次元ベクトル型

戻り値: 要素型

参照元 TQuaternion< float >::RotationArc().

TYPENAME AD::ret_type PTM::cross	(	const TVectorBase< 3, AD > &	a,
		const TVectorBase< 3, BD > &	b
	)

引数

a	3次元ベクトル型
b	3次元ベクトル型

戻り値: 3次元ベクトル型

void PTM::div	(	VectorImp< AD > &	a,
		const TYPENAME AD::element_type &	b
	)

引数

b 要素型.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::div().

TYPENAME AD::element_type PTM::dot	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

inline

引数

b	同じサイズのベクトル.

戻り値: 内積の値(要素型)

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

void PTM::element_max_impl	(	VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

b	同じサイズのベクトル.

参照先 VectorImp< D >::item(), Spr::max(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::element_max().

void PTM::element_min_impl	(	VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

b	同じサイズのベクトル.

参照先 VectorImp< D >::item(), Spr::min(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::element_min().

bool PTM::equal	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

b	同じサイズのベクトル.

戻り値: bool値.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::equal().

void PTM::init_rot	(	TMatrixBase< 3, 3, MD > &	m,
		TYPENAME MD::element_type	th,
		const TVectorBase< 3, AD > &	axis
	)

+                                                                      +
|u^2+(1-u^2)cos(th)      uv(1-cos(th))-wsin(th)  wu(1-cos(th))+vsin(th)|

R = |uv(1-cos(th))+wsin(th) v^2+(1-v^2)cos(th) vw(1-cos(th))-usin(th)| |wu(1-cos(th))-vsin(th) vw(1-cos(th))+usin(th) w^2+(1-w^2)cos(th) |

+

参照先 VectorImp< D >::item().

TYPENAME AD::ret_type PTM::interpolate	(	TYPENAME AD::element_type &	t,
		const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

t	補間量0-1
a	ベクトル
b	同じサイズのベクトル

参照先 VectorImp< D >::size().

void PTM::multi	(	VectorImp< AD > &	a,
		const TYPENAME AD::element_type &	b
	)

引数

b 要素型.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::multi().

void PTM::multi_each	(	VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

b 要素型.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

bool PTM::operator!=	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル型
b	要素型aと同じ次元数のベクトル型

戻り値: bool

参照先 VectorImp< D >::equal().

TYPENAME BD::ret_type PTM::operator*	(	const TYPENAME BD::element_type &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル型
b	要素型

戻り値: ベクトル型

TYPENAME BD::ret_type PTM::operator*	(	const VectorImp< BD > &	a,
		const TYPENAME BD::element_type &	b
	)

ベクトルとスカラーは可換なため．

引数

a	要素型
b	ベクトル型

戻り値: ベクトル型

AD::element_type PTM::operator*	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

inline

引数

a	ベクトル型
b	aと同じ次元数のベクトル型

戻り値: 要素型

参照先 VectorImp< D >::dot().

TYPENAME AD::ret_type PTM::operator+	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル型
b	aと同じ次元数のベクトル型

戻り値: aと同じ次元数のTVector型

TYPENAME AD::ret_type PTM::operator-	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル型
b	aと同じ次元数のベクトル型

戻り値: aと同じ次元数のベクトル型

bool PTM::operator==	(	const VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル型
b	要素型aと同じ次元数のベクトル型

戻り値: bool

参照先 VectorImp< D >::equal().

void PTM::sub	(	VectorImp< AD > &	a,
		const VectorImp< BD > &	b
	)

引数

a	ベクトル.
b	同じサイズのベクトル.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::sub().

モジュール

ファイル

構成

マクロ定義

型定義

関数

演算.

説明

マクロ定義

関数