期待suqingnian.h

不定期更新，跟着自己的进度走的。

有什么好的东西可以收录的尽管留言

UPD:话说真的没人发现本宝宝的$Martix$类的$operator$打错了么？$qwq$ $2018.7.19$

/*by Qingnian Su,Only want to write sonething useful*/
#ifndef suqingnian
#define suqingnian

template<typename _Element_pow>
  _Element_pow
    _pow(_Element_pow _a,_Element_pow _b,_Element_pow _mod)
    {
        _Element_pow _res=;
        for(;_b;_b >>= , _a= _a * _a % _mod)
          if(_b & ) _res = _res * _a % _mod;
        return _res ;
    }

template<typename _Element_gcd>
  _Element_gcd
    _gcd(_Element_gcd _m, _Element_gcd _n)
    {
        while (_n != )
        {
          _Element_gcd _t = _m % _n;
          _m = _n;
          _n = _t;
        }
      return _m;
    }

    bool __check[];
    int __size;
    int _num[];
    void _prime(int __n)
    {
      for(int _i=;_i<=__n;_i++)
        {
          if(!__check[_i]) _num[__size++]=_i;
          for(int _j=;_j<__size;_j++)
          {
            if(_i*_num[_j]>__n) break;
            __check[_num[_j]*_i]=;
            if(_i%_num[_j]==) break;
          }
        }
      return ;
    }
    bool _isprime(int __n) {return ~__check[__n];}

template<typename _Element_stack>
struct _stack{
    _Element_stack __st[];
    int __size_st;
    void __push(_Element_stack __x)
      {__st[++__size_st]=__x;return ;}
    void __pop()
      {__size_st--;return ;}
    _Element_stack __top()
      {return __st[__size_st];}
    bool _empty() {return __size_st==;}
};

template<typename _Element_compare_max>
    _Element_compare_max
        _max(
            const _Element_compare_max &a,
              const _Element_compare_max &b    )
        { return a > b ? a : b ;}

template<typename _Element_compare_min>
    _Element_compare_min
        _min(
            const _Element_compare_min &a,
              const _Element_compare_min &b    )
        { return a > b ? b : a ;}

template<typename _Element_fabs>
    _Element_fabs
        _fabs(
            const _Element_fabs &a    )
        {return a>(_Element_fabs)?a:-a;}

template<typename _Element_swap>
    void
        _swap(
            _Element_swap &a,
            _Element_swap &b    ){
            a^=b^=a^=b;
            return ;
        }    

#include<cstdio>
struct file_io{
    #define isdigit(ch) ((ch) >= '0' && (ch) <= '9')
    char inbuf[  <<  ], *pin ,
      outbuf[  <<  ], *pout ;
    int stk[  ] ;

    file_io():
      pout( outbuf ) {
        fread( pin = inbuf, ,  <<  , stdin );
    }

    ~file_io() {
        fwrite( outbuf ,  , pout - outbuf , stdout ) ;
    }

    inline void
      getint( int &num ){
            bool
              neg =  ;
            num = ;
            while( !isdigit( *pin ))
              if( *pin++ ==  '-' )
                neg = ;
            while( isdigit( *pin ))
              num = num *  + *pin++ - '';
            if( neg )
              num = -num;
        }

    inline void
      putint( int num ){
            static int
              *v = stk;
            if( !num )
              *pout++ = '';
            else{
                if( num < )
                  *pout++ = '-', num = -num;
                for( ; num ; num /= )
                  *v++ = num % ;
                while(v != stk )
            *pout++ = *--v + '';
            }
        }

    inline void
      nextline() {
        *pout++ = '\n';
    }
}fio;
#define getint(num) fio.tint(num)
#define putint(num) fio.putint(num)
#define nextline() fio.nextline()
//template<typename _Element_Martix>
const double eps=0.00000000000000000001;
struct _Martix{
    int
      num[][];
    int  siz;
    friend _Martix operator*
      ( const _Martix &__a,const _Martix &__b)
        {
            _Martix __c;
            int _n
                = _max ( __a.siz , __b.siz );

            for( int _k =  ; _k < _n ; _k ++ )
                for( int _i =  ; _i < _n ; _i ++ )
                    for( int _j = ; _j < _n ; _j ++ )
                        __c.num[_i][_j] +=
                            __a.num[_i][_k] * __b.num[_k][_j] ;

            __c.siz = _n;
            return __c;
        }

    friend _Martix operator+
      ( const _Martix &__a,const _Martix &__b)
        {
            _Martix __c;
            int _n
                = _max ( __a.siz , __b.siz );
                for( int _i =  ; _i < _n ; _i ++ )
                    for( int _j = ; _j < _n ; _j ++ )
                        __c.num[_i][_j] = __a.num[_i][_j] + __b.num[_i][_j] ;
            __c.siz = _n;
            return __c;
        }

    friend _Martix operator-
      ( const _Martix &__a,const _Martix &__b)
        {
            _Martix __c;
            int _n
                = _max ( __a.siz , __b.siz );
                for( int _i =  ; _i < _n ; _i ++ )
                    for( int _j = ; _j < _n ; _j ++ )
                        __c.num[_i][_j] = __a.num[_i][_j] - __b.num[_i][_j] ;
            __c.siz = _n;
            return __c;
        }
/*
    inline int* operator []
      ( const int& __x )
        {return num[__x];}

    inline bool cmp(const double &x){
        return x < -eps ? - : x > eps ;}

    inline double
    _getnum(){
        double ans = 1.0 ;
        for( int i =  ; i <= siz ; i ++ ){
            int nw = i;
            for( int j = i +  ; j <= siz ; j ++ )
                if(_fabs(num[j][i]) > _fabs(num[nw][i]))
                    nw=j;

            for( int j =  ; j <= siz ; j ++ )
                _swap(num[nw][j],num[i][j]);

            for( int j = i +  ; j <= siz ; j ++ ){
                double t = num[j][i]/num[i][i];
                for( int k = i ; k <= siz ; k ++ )
                    num[j][k] -= num[i][k] * t;
            }

            if(!cmp(num[i][i])) return 0.0;
            ans *= num[i][i];
        }
        return _fabs( ans );
    }
*/
};

#endif

本宝宝暂时把$128int$注释掉了，因为本宝宝写挂了。