C++ Matrix::Cols方法代码示例

bool SlaveTrainer::LayerActivation(double* up_ao, const double* low_ao, Matrix& w, const EActType eActType)
{
	if(!up_ao || !low_ao || w.IsNull())
		return false; 

	double e = 0.0; 
	for(int32_t j = 0; j < w.Cols(); j++) 
	{
		// forward propagation
		up_ao[j] = w[w.Rows()-1][j]; 	// bias
		for(int32_t i = 0; i < w.Rows() - 1; i++)
			up_ao[j] += w[i][j] * low_ao[i];

		// activation	
		if(eActType == _ACT_SOFTMAX)
			e += exp(up_ao[j]); 
		else
			up_ao[j] = Activation::Activate(up_ao[j], eActType); 
	}	
	if(eActType == _ACT_SOFTMAX)
	{ // softmax
		for(int32_t j = 0; j < w.Cols(); j++) 
			up_ao[j] = exp(up_ao[j]) / e; 
	}

	return true; 
}

Matrix operator-(Matrix a,Matrix b){
	Matrix result(a.Rows(),a.Cols());
	for(int i = 0 ; i < a.Rows() ; i++)
		for( int j = 0 ; j < a.Cols() ; j++)
			result.Set(j,i,a.Get(j,i) - b.Get(j,i));
	return result;
}

// C = A*b
Matrix operator*(const Matrix& A, const double b) {
  Matrix C(A.Rows(),A.Cols());
  for (size_t j=0; j<A.Cols(); j++)
    for (size_t i=0; i<A.Rows(); i++)
      C.data[j][i] = A.data[j][i] * b;
  return C;
}

Matrix operator*(const Matrix &left, const double right)
{
   Matrix M(left.Rows(), left.Cols());
   int i, j;
   for(i=0; i<left.Rows(); i++)
      for(j=0; j<left.Cols(); j++)
         M[i][j] = left[i][j] * right;
   return M;
}

Matrix TransposeMatrix(const Matrix& other)
{
   Matrix M(other.Cols(), other.Rows());
   int i, j;
   for(i=0; i<other.Rows(); i++)
      for(j=0; j<other.Cols(); j++)
         M[j][i] = other[i][j];
   return M;
}

// standard matrix-vector product
vector<double> MatVec(const Matrix& A, const vector<double>& v) {
  vector<double> res(0.0, A.Rows());
  if (A.Cols() != v.size()) {
    cerr << "MatVec: incompatible matrix/vector sizes in A*v\n";
  } else {
    for (size_t i=0; i<A.Rows(); i++) 
      for (size_t j=0; j<A.Cols(); j++)
	res[i] += A(i,j)*v[j];
  }
  return res;
}

// column/row vector dot product, something else for matrices?
double Dot(const Matrix& A, const Matrix& B) {
  double sum=0.0;
  if ((A.Cols() != B.Cols()) || (A.Rows() != B.Rows())) {
    cerr << "Dot error, matrix objects must be the same size\n";
  } else {
    for (size_t j=0; j<A.Cols(); j++) 
      for (size_t i=0; i<A.Rows(); i++)
	sum += A(i,j) * B(i,j);
  }
  return sum;
}

Matrix ScalarMultiply(const Matrix &left, const Matrix &right)
{
   wxASSERT(left.Rows() == right.Rows());
   wxASSERT(left.Cols() == right.Cols());
   Matrix M(left.Rows(), left.Cols());
   int i, j;
   for(i=0; i<left.Rows(); i++)
      for(j=0; j<left.Cols(); j++)
         M[i][j] = left[i][j] * right[i][j];
   return M;
}

Vector operator*(const Matrix &left, const Vector &right)
{
   wxASSERT(left.Cols() == right.Len());
   Vector v(left.Rows());
   int i, j;
   for(i=0; i<left.Rows(); i++) {
      v[i] = 0.0;
      for(j=0; j<left.Cols(); j++)
         v[i] += left[i][j] * right[j];
   }
   return v;
}

Matrix operator*(const Matrix &mat1, const Matrix &mat2)
{
	Matrix result;
	for (int ix = 0; ix < mat1.Rows(); ++ix) {
		for (int jx = 0; jx < mat1.Cols(); ++jx) {
			result(ix, jx) = 0;
			for (int kx = 0; kx < mat1.Cols(); ++kx)
				result(ix, jx) += mat1(ix, kx) * mat2(kx, jx);
		}
	}
	return result;
}

Matrix MatrixConcatenateCols(const Matrix& left, const Matrix& right)
{
   wxASSERT(left.Rows() == right.Rows());
   Matrix M(left.Rows(), left.Cols() + right.Cols());
   int i, j;
   for(i=0; i<left.Rows(); i++) {
      for(j=0; j<left.Cols(); j++)
         M[i][j] = left[i][j];
      for(j=0; j<right.Cols(); j++)
         M[i][j+left.Cols()] = right[i][j];
   }
   return M;
}

Matrix MatrixMultiply(const Matrix &left, const Matrix &right)
{
   wxASSERT(left.Cols() == right.Rows());
   Matrix M(left.Rows(), right.Cols());
   int i, j, k;
   for(i=0; i<left.Rows(); i++)
      for(j=0; j<right.Cols(); j++) {
         M[i][j] = 0.0;
         for(k=0; k<left.Cols(); k++)
            M[i][j] += left[i][k] * right[k][j];
      }
   return M;
}

// backward substitution on U*x = b, returning x as a new vector<double>
//    U and b remain unchanged in this operation
vector<double> BackSub(const Matrix& U, const vector<double>& b) {
  if (U.Rows() != b.size() || U.Rows() != U.Cols()) {
    cerr << "BackSub error, illegal matrix/vector dimensions\n";
    cerr << "  Matrix is " << U.Rows() << " x " << U.Cols() 
	 << ",  rhs is " << b.size() << " x 1\n";
    return vector<double>(0);
  }

  // create output vector, call existing BackSub routine, and return
  vector<double> x(0.0, U.Cols());
  if (BackSub(U, x, b) != 0)
    cerr << "BackSub Warning: error in BackSub call\n";
  return x;
}

// forward substitution on L*x = b, returning x as a new vector<double>
//    L and b remain unchanged in this operation
vector<double> FwdSub(const Matrix& L, const vector<double>& b) {
  // check that matrix sizes match
  if (L.Rows() != b.size() || L.Rows() != L.Cols()) {
    cerr << "FwdSub error, illegal matrix/vector dimensions\n";
    cerr << "  Matrix is " << L.Rows() << " x " << L.Cols() 
	 << ",  rhs is " << b.size() << " x 1\n";
    return vector<double>(0);
  }

  // create output vector and return
  vector<double> x(0.0, L.Cols());
  if (FwdSub(L, x, b) != 0)
    cerr << "FwdSub Warning: error in FwdSub call\n";
  return x;
}

    //exponential of a matrix (element-wise)
Matrix exp(const Matrix& A){

    size_t zeros = UNDEFINED;
    Matrix E(A.Rows(), A.Cols());
    
    for (size_t a = 0; a < A.Rows(); a++)
        for (size_t b = 0; b < A.Cols(); b++) {
            E.M[a * (A.Cols()) + b] = exp(A.M[a * (A.Cols()) + b]);
            CheckZero(&zeros, E.M[a * (A.Cols()) + b]);
        }
    
    if (zeros == ZERO)
        E._isZero = true;
    
    return E;
}