C++ (Cpp) SparseMatrix::MultiplyVector Examples

Example #1

File: CGSolver.cpp Project: jonntd/LocoSoftMayaPlugin

void CGSolver::DefaultMultiplicator(const void * data, const double * x, double * Ax)
{
  SparseMatrix * A = (SparseMatrix*)data;
  A->MultiplyVector(x, Ax);
}

Example #2

File: nonlinearModes.cpp Project: ricortiz/VegaFEM-cmake

void * MyFrame::NonLinearModesWorker(int * code, int dataOrigin, int numNonLinearModes, double ** modes_ )
{
  int n3 = 3 * precomputationState.simulationMesh->getNumVertices();
  int numDataVectors = 0;

  // compute the lumped mass matrix
  SparseMatrix * massMatrix; // will be sparse n3 x n3
  GenerateMassMatrix::computeMassMatrix( precomputationState.simulationMesh, &massMatrix, true); // exitCode will always be 0

  // mass-normalize modal derivatives
  double * modalDerivatives = precomputationState.modalDerivativesMatrix->GetMatrix();
  double * normalizedModalDerivatives = (double*) malloc (sizeof(double) * n3 * precomputationState.numDeriv);
  memcpy(normalizedModalDerivatives, modalDerivatives, sizeof(double) * n3 * precomputationState.numDeriv);

  for(int i=0; i < precomputationState.numDeriv; i++)
    massMatrix->NormalizeVector(&(normalizedModalDerivatives[n3 * i]));

  double * dataMatrix;
  if (dataOrigin == 0)
  {
    // use linear modes and derivatives
    // construct PCA data matrix:
    int numUsedLinearModes = precomputationState.rLin - precomputationState.numRigidModes;
    numDataVectors = numUsedLinearModes + numUsedLinearModes * (numUsedLinearModes + 1) / 2;
    printf("Number of PCA datamatrix columns: %d.\n", numDataVectors);
    dataMatrix = (double*) malloc (sizeof(double) * n3 * numDataVectors);

    printf("Generating datamatrix for SVD...\n");

    double lambda0 = precomputationState.frequencies[precomputationState.numRigidModes] * precomputationState.frequencies[precomputationState.numRigidModes];

    // scale linear modes 
    double * Ulin = precomputationState.linearModalMatrix->GetMatrix();
    for(int i=0; i<numUsedLinearModes; i++)
    {
      double lambda = precomputationState.frequencies[precomputationState.numRigidModes + i] * precomputationState.frequencies[precomputationState.numRigidModes + i];
      double factor = lambda0 / lambda;
      for(int vertex=0; vertex< n3; vertex++)
        dataMatrix[ELT(n3,vertex,i)] = factor * Ulin[ELT(n3,vertex,precomputationState.numRigidModes + i)];
    } 

    // scale modal derivatives
    int pos = 0;
    for(int i=0; i<numUsedLinearModes; i++)
    {
      for(int j=i; j<numUsedLinearModes; j++)
      {
        double lambdai = precomputationState.frequencies[precomputationState.numRigidModes + i] * precomputationState.frequencies[precomputationState.numRigidModes + i];
        double lambdaj = precomputationState.frequencies[precomputationState.numRigidModes + j] * precomputationState.frequencies[precomputationState.numRigidModes + j];
        double factor = lambda0 * lambda0 / (lambdai * lambdaj);

        for(int vertex=0; vertex < n3; vertex++)
          dataMatrix[ELT(n3, vertex, numUsedLinearModes + pos)] = 
            factor * normalizedModalDerivatives[ELT(n3, vertex, pos)];
        pos++;
      }
    }
  }
  else
  {
    // data from external simulation
    numDataVectors = precomputationState.sketchDataMatrix->Getr();
    dataMatrix = (double*) malloc (sizeof(double) * n3 * numDataVectors);
    memcpy(dataMatrix, precomputationState.sketchDataMatrix->GetMatrix(), sizeof(double) * n3 * numDataVectors);
  }

  free(normalizedModalDerivatives);

  // do lumped-mass-PCA on dataMatrix ( n3 x numDataVectors )
  
  double * ones = (double*) malloc (sizeof(double) * n3);
  for(int i=0; i<n3; i++)
    ones[i] = 1.0;

  double * LTDiagonal = (double*) malloc (sizeof(double) * n3);
  massMatrix->MultiplyVector(ones, LTDiagonal);
  free(ones);
  delete(massMatrix);

  // sqrt
  for(int i=0; i<n3; i++)
    LTDiagonal[i] = sqrt(LTDiagonal[i]);

  // number of retained dimensions can't be more than num linear modes + num derivatives
  if (uiState.numComputedNonLinearModes > numDataVectors)
    uiState.numComputedNonLinearModes = numDataVectors;

  // premultiply by LT
  for(int i=0; i<n3; i++)
    for(int j=0; j < numDataVectors; j++)
      dataMatrix[ELT(n3, i, j)] *= LTDiagonal[i];

  // do SVD on dataMatrix ( n3 x numDataVectors ), retain uiState.numComputedNonLinearModes modes

  ThresholdingSpecification thresholdingSpecification;
  thresholdingSpecification.tresholdingType = ThresholdingSpecification::numberOfModesBased;
  thresholdingSpecification.rDesired = uiState.numComputedNonLinearModes;

  int outputr;
  int matrixPCACode = 0;
  if ( ((matrixPCACode = MatrixPCA(
    &thresholdingSpecification, n3, numDataVectors, dataMatrix, &outputr)) != 0) 
    || (outputr != uiState.numComputedNonLinearModes))
  {
    printf("Error performing SVD. Code: %d\n", matrixPCACode);
    *code = matrixPCACode;
    free(dataMatrix);
    free(LTDiagonal);
    return NULL;
  }

  // solve L^T U = V
  for(int i=0; i<n3; i++)
    for(int j=0; j < uiState.numComputedNonLinearModes; j++)
      dataMatrix[ELT(n3, i, j)] /= LTDiagonal[i];

  free(LTDiagonal);

  // export data
  *modes_ = (double*) realloc (dataMatrix, 
    sizeof(double) * n3 * uiState.numComputedNonLinearModes);

  computationRunning = -1;

  *code = 0;
  return NULL;
}