丰县宋楼镇油页岩:定义一个矩阵类，含有加减乘除运算函数。

标准库已经有了，其定义如下：
template<class _Ty>
class valarray
{ // store array with various indexing options
public:
typedef _Ty value_type;

explicit valarray(size_t _Count = 0)
{ // construct with _Count * _Ty()
_Tidy();
_Myres = _Count;
_Grow(_Count);
}

valarray(const _Ty& _Val, size_t _Count)
{ // construct with _Count * _Val
_Tidy();
_Grow(_Count, &_Val);
}

valarray(const _Ty *_Ptr, size_t _Count)
{ // construct with [_Ptr, _Ptr + _Count)
_Tidy();
_Grow(_Count, _Ptr, 1);
}

valarray(const valarray<_Ty>& _Right)
{ // construct from valarray
_Tidy();
_Grow(_Right.size(), _Right._Myptr, 1);
}

valarray(const slice_array<_Ty>& _Slicearr)
{ // construct from slice_array
_Tidy();
*this = _Slicearr;
}

valarray(const gslice_array<_Ty>& _Gslicearr)
{ // construct from gslice_array
_Tidy();
*this = _Gslicearr;
}

valarray(const mask_array<_Ty>& _Maskarr)
{ // construct from mask_array
_Tidy();
*this = _Maskarr;
}

valarray(const indirect_array<_Ty>& _Indarr)
{ // construct from indirect_array
_Tidy();
*this = _Indarr;
}

~valarray()
{ // destroy the object
_Tidy(true);
}

valarray<_Ty>& operator=(const valarray<_Ty>& _Right)
{ // assign valarray _Right
if (this == &_Right)
; // do nothing
else if (size() == _Right.size())
for (size_t _Idx = 0; _Idx < size(); ++_Idx)
_Myptr[_Idx] = _Right[_Idx];
else
{ // resize and copy
_Tidy(true);
_Grow(_Right.size(), _Right._Myptr, 1);
}
return (*this);
}

valarray<_Ty>& operator=(const _Ty& _Val)
{ // assign _Val to each element
_VALGOP(= _Val);
}

void resize(size_t _Newsize)
{ // determine new length, padding with _Ty() elements as needed
resize(_Newsize, _Ty());
}

void resize(size_t _Newsize, const _Ty _Val)
{ // determine new length, padding with _Val elements as needed
_Grow(0, &_Val, 0);
_Grow(_Newsize, &_Val, 0);
}

valarray<_Ty>& operator=(
const slice_array<_Ty>& _Slicearr); // defined below

valarray<_Ty>& operator=(
const gslice_array<_Ty>& _Gslicearr); // defined below

valarray<_Ty>& operator=(
const mask_array<_Ty>& _Maskarr); // defined below

valarray<_Ty>& operator=(
const indirect_array<_Ty>& _Indarr); // defined below

valarray<_Ty> operator+() const
{ // return +valarray
_VALOP(_Ty, size(), +_Myptr[_Idx]);
}

valarray<_Ty> operator-() const
{ // return -valarray
_VALOP(_Ty, size(), -_Myptr[_Idx]);
}

valarray<_Ty> operator~() const
{ // return ~valarray
_VALOP(_Ty, size(), ~_Myptr[_Idx]);
}

_Boolarray operator!() const
{ // return !valarray
_VALOP(_Bool, size(), !_Myptr[_Idx]);
}

valarray<_Ty>& operator*=(const _Ty& _Right)
{ // multiply valarray elements by _Right
_VALGOP(*= _Right);
}

valarray<_Ty>& operator/=(const _Ty& _Right)
{ // divide valarray elements by _Right
_VALGOP(/= _Right);
}

valarray<_Ty>& operator%=(const _Ty& _Right)
{ // remainder valarray elements by _Right
_VALGOP(%= _Right);
}

valarray<_Ty>& operator+=(const _Ty& _Right)
{ // add _Right to valarray elements
_VALGOP(+= _Right);
}

valarray<_Ty>& operator-=(const _Ty& _Right)
{ // subtract _Right from valarray elements
_VALGOP(-= _Right);
}

valarray<_Ty>& operator^=(const _Ty& _Right)
{ // XOR _Right into valarray elements
_VALGOP(^= _Right);
}

valarray<_Ty>& operator&=(const _Ty& _Right)
{ // AND _Right into valarray elements
_VALGOP(&= _Right);
}

valarray<_Ty>& operator|=(const _Ty& _Right)
{ // OR _Right into valarray elements
_VALGOP(|= _Right);
}

valarray<_Ty>& operator<<=(const _Ty& _Right)
{ // left shift valarray elements by _Right
_VALGOP(<<= _Right);
}

valarray<_Ty>& operator>>=(const _Ty& _Right)
{ // right shift valarray elements by _Right
_VALGOP(>>= _Right);
}

valarray<_Ty>& operator*=(const valarray<_Ty>& _Right)
{ // multiply valarray elements by valarray _Right elements
_VALGOP(*= _Right[_Idx]);
}

valarray<_Ty>& operator/=(const valarray<_Ty>& _Right)
{ // divide valarray elements by valarray _Right elements
_VALGOP(/= _Right[_Idx]);
}

valarray<_Ty>& operator%=(const valarray<_Ty>& _Right)
{ // remainder valarray elements by valarray _Right elements
_VALGOP(%= _Right[_Idx]);
}

valarray<_Ty>& operator+=(const valarray<_Ty>& _Right)
{ // add valarray _Right elements to valarray elements
_VALGOP(+= _Right[_Idx]);
}

valarray<_Ty>& operator-=(const valarray<_Ty>& _Right)
{ // subtract valarray _Right elements from valarray elements
_VALGOP(-= _Right[_Idx]);
}

valarray<_Ty>& operator^=(const valarray<_Ty>& _Right)
{ // XOR valarray _Right elements into valarray elements
_VALGOP(^= _Right[_Idx]);
}

valarray<_Ty>& operator|=(const valarray<_Ty>& _Right)
{ // OR valarray _Right elements into valarray elements
_VALGOP(|= _Right[_Idx]);
}

valarray<_Ty>& operator&=(const valarray<_Ty>& _Right)
{ // AND valarray _Right elements into valarray elements
_VALGOP(&= _Right[_Idx]);
}

valarray<_Ty>& operator<<=(const valarray<_Ty>& _Right)
{ // left shift valarray elements by valarray _Right elements
_VALGOP(<<= _Right[_Idx]);
}

valarray<_Ty>& operator>>=(const valarray<_Ty>& _Right)
{ // right shift valarray elements by valarray _Right elements
_VALGOP(>>= _Right[_Idx]);
}

size_t size() const
{ // return length of sequence
return (_Mysize);
}

_Ty operator[](size_t _Off) const
{ // subscript nonmutable sequence
return (_Myptr[_Off]);
}

_Ty& operator[](size_t _Off)
{ // subscript mutable sequence
return (_Myptr[_Off]);
}

valarray<_Ty> operator[](
slice _Slicearr) const; // defined below

slice_array<_Ty> operator[](
slice _Slicearr); // defined below

valarray<_Ty> operator[](
const gslice& _Gslicearr) const; // defined below

gslice_array<_Ty> operator[](
const gslice& _Gslicearr); // defined below

valarray<_Ty> operator[](
const _Boolarray& _Boolarr) const; // defined below

mask_array<_Ty> operator[](
const _Boolarray& _Boolarr); // defined below

valarray<_Ty> operator[](
const _Sizarray& _Indarr) const; // defined below

indirect_array<_Ty> operator[](
const _Sizarray& _Indarr); // defined below

_Ty sum() const
{ // return sum all elements
_Ty _Sum = _Myptr[0];
for (size_t _Idx = 0; ++_Idx < size(); )
_Sum += _Myptr[_Idx];
return (_Sum);
}

_Ty min() const
{ // return smallest of all elements
_Ty _Min = _Myptr[0];
for (size_t _Idx = 0; ++_Idx < size(); )
if (_Myptr[_Idx] < _Min)
_Min = _Myptr[_Idx];
return (_Min);
}

_Ty max() const
{ // return largest of all elements
_Ty _Max = _Myptr[0];
for (size_t _Idx = 0; ++_Idx < size(); )
if (_Max < _Myptr[_Idx])
_Max = _Myptr[_Idx];
return (_Max);
}

valarray<_Ty> shift(int _Count) const
{ // return valarray left shifted
__PURE_APPDOMAIN_GLOBAL static _Ty _Dflt;
_VALOP(_Ty, size(),
0 < _Count && size() - _Idx <= (size_t)_Count
|| _Count < 0 && _Idx < (size_t)-_Count
? _Dflt : _Myptr[_Idx + _Count]);
}

valarray<_Ty> cshift(int _Count) const
{ // return valarray left rotated
if (size() == 0)
; // no shift
else if (_Count < 0)
{ // right shift
if (size() < (size_t)0 - _Count)
_Count = (int)(size() - ((size_t)0 - _Count - size())
% size());
else
_Count = (int)(size() + _Count);
}
else if (size() <= (size_t)_Count)
_Count %= size();

_VALOP(_Ty, size(), size() - _Idx <= (size_t)_Count
? _Myptr[_Idx - size() + _Count] : _Myptr[_Idx + _Count]);
}

valarray<_Ty> apply(_Ty _Func(_Ty)) const
{ // return valarray transformed by _Func, value argument
_VALOP(_Ty, size(), _Func(_Myptr[_Idx]));
}

valarray<_Ty> apply(_Ty _Func(const _Ty&)) const
{ // return valarray transformed by _Func, nonmutable argument
_VALOP(_Ty, size(), _Func(_Myptr[_Idx]));
}

void free() // retained
{ // erase all elements
_Tidy(true);
}

private:
void _Grow(size_t _Count,
const _Ty *_Ptr = 0,
size_t _Inc = 0)
{ // grow to _Count elements and pad
size_t _Oldsize = _Myptr == 0 ? 0 : _Myres;

if (_Count == 0)
_Tidy(true); // new sequence empty
else if (_Count == _Oldsize || _Count < _Oldsize)
; // big enough, no need to pad
else
{ // allocate new array, copy and pad
size_t _Idx;
size_t _Newsize = _Myptr == 0 && _Count < _Myres
? _Myres : _Count;
_Ty *_Newptr = 0;
size_t _Nm = _Count < _Mysize ? _Count : _Mysize;
if (_Myptr == 0)
{
_Nm = 0;
}
#pragma warning(push)
#pragma warning(disable: 6011)
_TRY_BEGIN
_Newptr = new _Ty[_Newsize];
_CATCH_ALL
_Tidy(true); // allocation failed, discard storage and reraise
_RERAISE;
_CATCH_END

for (_Idx = 0; _Idx < _Nm; ++_Idx)
_Newptr[_Idx] = _Myptr[_Idx];
if (_Ptr != 0)
for (; _Idx < _Newsize; ++_Idx, _Ptr += _Inc)
_Newptr[_Idx] = *_Ptr;

_Tidy(true);
_Myptr = _Newptr;
_Myres = _Newsize;
#pragma warning(pop)
}
_Mysize = _Count;
}

void _Tidy(bool _Constructed = false)
{ // initialize the object, freeing any allocated storage
if (_Constructed && _Myptr != 0)
delete[] _Myptr;
_Mysize = 0;
_Myptr = 0;
_Myres = 0;
}

_Ty *_Myptr; // current storage reserved for array
size_t _Mysize; // current length of sequence
size_t _Myres; // length of array
};

// valarray TEMPLATE FUNCTIONS
template<class _Ty> inline
valarray<_Ty> operator*(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray * scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right);
}

template<class _Ty> inline
valarray<_Ty> operator*(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar * valarray
_VALOP(_Ty, _Right.size(), _Left * _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator/(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray / scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right);
}

template<class _Ty> inline
valarray<_Ty> operator/(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar / valarray
_VALOP(_Ty, _Right.size(), _Left / _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator%(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray % scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right);
}

template<class _Ty> inline
valarray<_Ty> operator%(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar % valarray
_VALOP(_Ty, _Right.size(), _Left % _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator+(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray + scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right);
}

template<class _Ty> inline
valarray<_Ty> operator+(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar + valarray
_VALOP(_Ty, _Right.size(), _Left + _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator-(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray - scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right);
}

template<class _Ty> inline
valarray<_Ty> operator-(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar - valarray
_VALOP(_Ty, _Right.size(), _Left - _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator^(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray ^ scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right);
}

template<class _Ty> inline
valarray<_Ty> operator^(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar ^ valarray
_VALOP(_Ty, _Right.size(), _Left ^ _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator&(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray & scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right);
}

template<class _Ty> inline
valarray<_Ty> operator&(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar & valarray
_VALOP(_Ty, _Right.size(), _Left & _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator|(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray | scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right);
}

template<class _Ty> inline
valarray<_Ty> operator|(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar | valarray
_VALOP(_Ty, _Right.size(), _Left | _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator<<(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray << scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right);
}

template<class _Ty> inline
valarray<_Ty> operator<<(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar << valarray
_VALOP(_Ty, _Right.size(), _Left << _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator>>(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray >> scalar
_VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right);
}

template<class _Ty> inline
valarray<_Ty> operator>>(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar >> valarray
_VALOP(_Ty, _Right.size(), _Left >> _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator&&(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray && scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] && _Right);
}

template<class _Ty> inline
_Boolarray operator&&(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar && valarray
_VALOP(_Bool, _Right.size(), _Left && _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator||(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray || scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] || _Right);
}

template<class _Ty> inline
_Boolarray operator||(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar || valarray
_VALOP(_Bool, _Right.size(), _Left || _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator*(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray * valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator/(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray ? valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator%(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray % valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator+(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray + valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator-(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray - valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator^(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray ^ valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator&(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray & valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator|(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray | valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator<<(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray << valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right[_Idx]);
}

template<class _Ty> inline
valarray<_Ty> operator>>(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray >> valarray
_VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator&&(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray && valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] && _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator||(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray || valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] || _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator==(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray == scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] == _Right);
}

template<class _Ty> inline
_Boolarray operator==(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar == valarray
_VALOP(_Bool, _Right.size(), _Left == _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator==(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray == valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] == _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator!=(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray != scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] != _Right);
}

template<class _Ty> inline
_Boolarray operator!=(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar != valarray
_VALOP(_Bool, _Right.size(), _Left != _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator!=(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray != valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] != _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator<(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray < scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] < _Right);
}

template<class _Ty> inline
_Boolarray operator<(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar < valarray
_VALOP(_Bool, _Right.size(), _Left < _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator<(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray < valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] < _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator>(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray > scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] > _Right);
}

template<class _Ty> inline
_Boolarray operator>(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar > valarray
_VALOP(_Bool, _Right.size(), _Left > _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator>(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray > valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] > _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator<=(const valarray<_Ty>& _Left,
const _Ty& _Right)
{ // return valarray <= scalar
_VALOP(_Bool, _Left.size(), _Left[_Idx] <= _Right);
}

template<class _Ty> inline
_Boolarray operator<=(const _Ty& _Left,
const valarray<_Ty>& _Right)
{ // return scalar <= valarray
_VALOP(_Bool, _Right.size(), _Left <= _Right[_Idx]);
}

template<class _Ty> inline
_Boolarray operator<=(const valarray<_Ty>& _Left,
const valarray<_Ty>& _Right)
{ // return valarray <= valarray
_VALOP(_Bool, _Left.size(), _Left[_Idx] <= _Right[_Idx]);
}

template<class _Ty> inline