// Licensed with GPL v2 #include #include #include using namespace std; namespace mat { // This allows us to associate any matrix // to a base class, grouping them together. struct Matrix {}; // Forward declarations template class Mat; template class sing; // Helper mat classes template using SqMat = Mat; template using ColVec = Mat; template using RowVec = Mat; // Built in singleton types namespace stypes { using Integer = sing; using Natural = sing; using Real = sing; } // This class is used to get the type // of a result of a matrix product. template struct _MatProd { using value = Mat::value, T::width, Q::height>; }; // First type has preference. //template<> template struct _MatProd, sing> { using value = sing; }; // Alias to get rid of typename and ::value template using MatProd = typename _MatProd::value; // Main matrix class template class Mat : public Matrix { protected: static constexpr const size_t datalen = w*h; // Data is stored row-first, // i.e. 1st row and 3rd column // will always be at data[2]. std::array data; public: // These are used to get the // matrix product type. using dtype = T; static constexpr size_t width = w; static constexpr size_t height = h; Mat(); Mat(const T&); Mat(const std::array&); T& get(size_t, size_t); template Mat& operator+=(Mat); template Mat operator+(Mat mat); template MatProd, Mat> operator*(Mat mat); // Used for printing. template friend std::ostream& operator<<(std::ostream&, Mat); }; template Mat::Mat() : data{} {} template Mat::Mat(const T& val) : data{} { for(auto& el : data) el = val; } template Mat::Mat(const std::array& val) : data{val} {} template T& Mat::get(size_t x, size_t y) { if( 0 <= x && x < w && 0 <= y && y < h ) return data[y * w + x]; throw std::runtime_error("Index out of bounds"); } template template Mat& Mat::operator+=(Mat mat) { for(size_t i = 0; i < datalen; ++i) data[i] += mat.data[i]; return *this; } template template Mat Mat::operator+(Mat mat) { Mat res = *this; return res += mat; } template template MatProd, Mat> Mat::operator*(Mat mat) { MatProd, Mat> res; for(size_t x = 0; x < w; ++x) for(size_t y = 0; y < h2; ++y) for(size_t k = 0; k < h; ++k) res.get(x, y) += this->get(x, k) * mat.get(k, y); return res; } template std::ostream& operator<<(std::ostream& os, Mat mat) { os << '{'; for(size_t y = 0; y < h; ++y) { os << '{'; for(size_t x = 0; x < w; ++x) { os << mat.get(x,y); if(x < w-1) os << ','; } os << '}'; if(y < h-1) os << ','; } os << '}'; return os; } /*Ring { zero() one() operator+(); operator*(); }*/ /*template class Ring { static const T zero; static const T one; operator+(); operator*(); } static const T zero; static const T one; template class T if(...) Ring::one();*/ // Singleton class, different from 1x1 matrix template class sing : public Mat { public: sing() : Mat() {} sing(const T& val) : Mat(val) {} template bool operator==(sing sin); template sing operator*(sing sin); template sing& operator+=(sing sin); static const sing zero; static const sing one; template friend std::ostream& operator<<(std::ostream& os, sing sin); }; template static const sing zero = T::zero(); template static const sing one = T::one(); // These specializations discard the ability // to use singletons containing matrices or singletons. //template<> template class sing> { virtual ~sing() = 0; }; //template<> template class sing> { virtual ~sing() = 0; }; template template bool sing::operator==(sing sin) { return this->data[0] == sin.data[0]; } template template sing sing::operator*(sing sin) { return this->data[0] * sin.data[0]; } template template sing& sing::operator+=(sing sin) { this->data[0] += sin.data[0]; return *this; } template std::ostream& operator<<(std::ostream& os, sing mat) { os << mat.data[0]; return os; } } // namespace mat using namespace mat; struct MyType { MyType() : val{} {} MyType(int x) : val{x} {} int val; bool operator==(MyType c) { return val == c.val; } MyType operator*(MyType c) { return val * c.val; } MyType& operator+=(MyType c) { val += c.val; return *this; } friend ostream& operator<<(ostream& os, MyType c) { os << c.val; return os; } }; #include struct String { String() : str{zero().str} {} template String(const char (&s)[n]) : str{s} {} String(const string& s) : str{s} {} static const String zero() { return {"0"}; } static const String one() { return {"1"}; } string str; bool operator==(String s) { return str == s.str; } bool operator!=(String s) { return str != s.str; } String operator*(String s) { if(s == one() && *this == one()) return one(); else if(s == one()) return *this; else if(*this == one()) return s; else if(*this != zero() && s != zero()) return {str + s.str}; else return zero(); } String& operator+=(String s) { if(s == zero() && *this == zero()) str = zero().str; else if(s == zero()) ; else if(*this == zero()) str = s.str; else if(*this != zero() && s != zero()) str = "(" + str + "+" + s.str + ")"; else str = s.str; return *this; } friend ostream& operator<<(ostream& os, String s) { os << s.str; return os; } }; int main() { using Integer = stypes::Integer; using Natural = stypes::Natural; // Can create custom types by creating a "sing"(singleton) object // with your type as template argument. using Type = sing; ColVec x {{ 1, 2 }}; SqMat f {{ 1, 2, 3, 4 }}; RowVec y {{ 1, 2 }}; auto res = x * f * y; cout << res << endl; cout << typeid(res).name() << endl; Mat m {{1,2,3,4}}; cout << Mat({1,2,3,4}) << endl; cout << Integer{5} << endl; cout << Natural{5} << endl; cout << Mat(5) << endl; // Cannot multiply properly if singleton is not used cout << Mat(5) << endl; Mat newmat({7}); cout << newmat * Mat({2}) << endl; array,4> arr{{"a",sing("0"),sing("b"),sing("c")}}; // Language Mat, 2,2> langmat{arr}; cout << langmat * langmat << endl; return 0; }

Linear algebra matrix library v0.1 (WIP)