Пример #1
1
bool link_sparse_hessian(
	size_t                           size     , 
	size_t                           repeat   , 
	CppAD::vector<double>&           x        ,
	const CppAD::vector<size_t>&     row      ,
	const CppAD::vector<size_t>&     col      ,
	CppAD::vector<double>&           hessian  )
{
	// -----------------------------------------------------
	// setup
	typedef vector<double>              DblVector;
	typedef vector< std::set<size_t> >  SetVector;
	typedef CppAD::AD<double>           ADScalar;
	typedef vector<ADScalar>            ADVector;

	size_t i, j, k;
	size_t order = 0;         // derivative order corresponding to function
	size_t m = 1;             // number of dependent variables
	size_t n = size;          // number of independent variables
	size_t K = row.size();    // number of non-zeros in lower triangle
	ADVector   a_x(n);        // AD domain space vector
	ADVector   a_y(m);        // AD range space vector
	DblVector  w(m);          // double range space vector
	DblVector hes(K);         // non-zeros in lower triangle
	CppAD::ADFun<double> f;   // AD function object

	// weights for hessian calculation (only one component of f)
	w[0] = 1.;

	// use the unspecified fact that size is non-decreasing between calls
	static size_t previous_size = 0;
	bool print    = (repeat > 1) & (previous_size != size);
	previous_size = size;

	// declare sparsity pattern
# if USE_SET_SPARSITY
	SetVector sparsity(n);
# else
	typedef vector<bool>                BoolVector;
	BoolVector sparsity(n * n);
# endif
	// initialize all entries as zero
	for(i = 0; i < n; i++)
	{	for(j = 0; j < n; j++)
			hessian[ i * n + j] = 0.;
	}
	// ------------------------------------------------------
	extern bool global_retape;
	if( global_retape) while(repeat--)
	{	// choose a value for x 
		CppAD::uniform_01(n, x);
		for(j = 0; j < n; j++)
			a_x[j] = x[j];

		// declare independent variables
		Independent(a_x);	

		// AD computation of f(x)
		CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);

		// create function object f : X -> Y
		f.Dependent(a_x, a_y);

		extern bool global_optimize;
		if( global_optimize )
		{	print_optimize(f, print, "cppad_sparse_hessian_optimize", size);
			print = false;
		}

		// calculate the Hessian sparsity pattern for this function
		calc_sparsity(sparsity, f);

		// structure that holds some of work done by SparseHessian
		CppAD::sparse_hessian_work work;

		// calculate this Hessian at this x
		f.SparseHessian(x, w, sparsity, row, col, hes, work);
		for(k = 0; k < K; k++)
		{	hessian[ row[k] * n + col[k] ] = hes[k];
			hessian[ col[k] * n + row[k] ] = hes[k];
		}
	}
	else
	{	// choose a value for x 
		CppAD::uniform_01(n, x);
		for(j = 0; j < n; j++)
			a_x[j] = x[j];

		// declare independent variables
		Independent(a_x);	

		// AD computation of f(x)
		CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);

		// create function object f : X -> Y
		f.Dependent(a_x, a_y);

		extern bool global_optimize;
		if( global_optimize )
		{	print_optimize(f, print, "cppad_sparse_hessian_optimize", size);
			print = false;
		}

		// calculate the Hessian sparsity pattern for this function
		calc_sparsity(sparsity, f);

		// declare structure that holds some of work done by SparseHessian
		CppAD::sparse_hessian_work work;

		while(repeat--)
		{	// choose a value for x
			CppAD::uniform_01(n, x);

			// calculate sparsity at this x
			f.SparseHessian(x, w, sparsity, row, col, hes, work);

			for(k = 0; k < K; k++)
			{	hessian[ row[k] * n + col[k] ] = hes[k];
				hessian[ col[k] * n + row[k] ] = hes[k];
			}
		}
	}
	return true;
}
Пример #2
0
 DataType& SparseStorage<DataType>::elem(casadi_int rr, casadi_int cc) {
   casadi_int oldsize = sparsity().nnz();
   casadi_int ind = sparsity_.add_nz(rr, cc);
   if (oldsize != sparsity().nnz())
     nonzeros().insert(nonzeros().begin()+ind, DataType(0));
   return nonzeros().at(ind);
 }
Пример #3
0
 DataType& SparseStorage<DataType>::elem(int rr, int cc) {
   int oldsize = sparsity().size();
   int ind = sparsityRef().getNZ(rr, cc);
   if (oldsize != sparsity().size())
     data().insert(begin()+ind, DataType(0));
   return at(ind);
 }
Пример #4
0
void Multiplication::generateOperation(std::ostream &stream, const std::vector<std::string>& arg, const std::vector<std::string>& res, CodeGenerator& gen) const{
  
  // Clear the result
  stream << "  casadi_fill(" << sparsity().size() << ",0.0," << res.front() << ",1);" << endl;

  // Perform sparse matrix multiplication
  stream << "  casadi_mm_nt_sparse(";
  for(int i=0; i<2; ++i){
    stream << arg.at(i) << ",s" << gen.getSparsity(dep(i).sparsity()) << ",";
  }
  stream << res.front() << ",s" << gen.getSparsity(sparsity()) << ");" << endl;
}
Пример #5
0
std::string Reshape::print(const std::vector<std::string>& arg) const {
    // For vectors, reshape is also a transpose
    if (dep().is_vector() && sparsity().is_vector()) {
        // Print as transpose: X'
        return arg.at(0) + "'";
    } else {
        // Print as reshape(X) or vec(X)
        if (sparsity().is_column()) {
            return "vec(" + arg.at(0) + ")";
        } else {
            return "reshape(" + arg.at(0) + ")";
        }
    }
}
Пример #6
0
 const DataType& SparseStorage<DataType>::elem(int rr, int cc) const {
   int ind = sparsity().getNZ(rr, cc);
   if (ind==-1)
     return casadi_limits<DataType>::zero;
   else
     return at(ind);
 }
Пример #7
0
 void Project::evalFwd(const std::vector<std::vector<MX> >& fseed,
                         std::vector<std::vector<MX> >& fsens) {
   int nfwd = fsens.size();
   for (int d=0; d<nfwd; ++d) {
     fsens[d][0] = project(fseed[d][0], sparsity(), true);
   }
 }
Пример #8
0
 void HorzRepsum::spAdj(bvec_t** arg, bvec_t** res, int* iw, bvec_t* w, int mem) {
   int nnz = sparsity().nnz();
   for (int i=0;i<n_;++i) {
     std::transform(res[0], res[0]+nnz, arg[0]+i*nnz, arg[0]+i*nnz, &Orring);
   }
   std::fill(res[0], res[0]+nnz, 0);
 }
Пример #9
0
 std::string Project::print(const std::vector<std::string>& arg) const {
   if (sparsity().isdense()) {
     return "dense(" + arg.at(0) + ")";
   } else {
     return "project(" + arg.at(0) + ")";
   }
 }
Пример #10
0
MX Reshape::getTranspose() const {
    // For vectors, reshape is also a transpose
    if (dep().is_vector() && sparsity().is_vector()) {
        return dep();
    } else {
        return MXNode::getTranspose();
    }
}
Пример #11
0
 void UnaryMX::generateOperation(std::ostream &stream, const std::vector<std::string>& arg, const std::vector<std::string>& res, CodeGenerator& gen) const{
   stream << "  for(i=0; i<" << sparsity().size() << "; ++i) ";
   stream << res.at(0) << "[i]=";
   casadi_math<double>::printPre(op_,stream);
   stream << arg.at(0) << "[i]";
   casadi_math<double>::printPost(op_,stream);
   stream << ";" << endl;
 }
Пример #12
0
  void Transpose::generate(const std::vector<int>& arg, const std::vector<int>& res,
                           CodeGenerator& g) const {
    g.addAuxiliary(CodeGenerator::AUX_TRANS);

    g.body << "  trans("
           << g.work(arg[0], nnz()) << ", " << g.sparsity(dep().sparsity()) << ", "
           << g.work(res[0], nnz()) << ", " << g.sparsity(sparsity()) << ", iw);" << endl;
  }
Пример #13
0
 void HorzRepsum::evalGen(const T** arg, T** res, int* iw, T* w, int mem,
                          R reduction) const {
   int nnz = sparsity().nnz();
   fill_n(res[0], nnz, 0);
   for (int i=0;i<n_;++i) {
     std::transform(arg[0]+i*nnz, arg[0]+(i+1)*nnz, res[0], res[0], reduction);
   }
 }
Пример #14
0
  void Transpose::spFwd(const bvec_t** arg,
                        bvec_t** res, int* iw, bvec_t* w) {
    // Shortands
    const bvec_t *x = arg[0];
    bvec_t *xT = res[0];

    // Get sparsity
    int nz = nnz();
    const int* x_row = dep().row();
    const int* xT_colind = sparsity().colind();
    int xT_ncol = sparsity().size2();

    // Loop over the nonzeros of the argument
    copy(xT_colind, xT_colind+xT_ncol+1, iw);
    for (int el=0; el<nz; ++el) {
      xT[iw[*x_row++]++] = *x++;
    }
  }
Пример #15
0
  void Transpose::evalGen(const T* const* arg, T* const* res,
                          int* iw, T* w) {
    // Get sparsity patterns
    //const vector<int>& x_colind = input[0]->colind();
    const int* x_row = dep(0).row();
    int x_sz = dep(0).nnz();
    const int* xT_colind = sparsity().colind();
    int xT_ncol = sparsity().size2();

    const T* x = arg[0];
    T* xT = res[0];

    // Transpose
    copy(xT_colind, xT_colind+xT_ncol+1, iw);
    for (int el=0; el<x_sz; ++el) {
      xT[iw[x_row[el]]++] = x[el];
    }
  }
Пример #16
0
 void HorzRepmat::generate(CodeGenerator& g, const std::string& mem,
                           const std::vector<int>& arg, const std::vector<int>& res) const {
   int nnz = dep(0).nnz();
   g.body << "  for (i=0;i<" << n_ << ";++i) {" << endl;
   g.body << "    " << g.copy(g.work(arg[0], dep(0).nnz()), nnz,
                              g.work(res[0], sparsity().nnz()) + "+ i*" + g.to_string(nnz))
          << endl
   << "  }" << endl;
 }
Пример #17
0
 void HorzRepsum::generate(CodeGenerator& g, const std::string& mem,
                           const std::vector<int>& arg, const std::vector<int>& res) const {
   int nnz = sparsity().nnz();
   g.body << "  " << g.fill(g.work(res[0], nnz), nnz, "0") << endl;
   g.body << "  for (i=0;i<" << n_ << ";++i) {" << endl;
   g.body << "    for (j=0;j<" << nnz << ";++j) {" << endl;
   g.body << "      " << g.work(res[0], nnz)<< "[j] += " <<
     g.work(arg[0], dep(0).nnz()) << "[j+i*" << nnz << "];" << endl;
   g.body << "    }" << endl;
   g.body << "  }" << endl;
 }
Пример #18
0
 void Split::spFwd(const bvec_t** arg, bvec_t** res, int* iw, bvec_t* w, int mem) {
   int nx = offset_.size()-1;
   for (int i=0; i<nx; ++i) {
     if (res[i]!=0) {
       const bvec_t *arg_ptr = arg[0] + offset_[i];
       int n_i = sparsity(i).nnz();
       bvec_t *res_i_ptr = res[i];
       for (int k=0; k<n_i; ++k) {
         *res_i_ptr++ = *arg_ptr++;
       }
     }
   }
 }
Пример #19
0
  bool GetNonzerosSlice::isIdentity() const {
    // Check sparsity
    if (!(sparsity() == dep().sparsity()))
      return false;

    // Check if the nonzeros follow in increasing order
    if (s_.start_ != 0) return false;
    if (s_.step_ != 1) return false;
    if (s_.stop_ != size()) return false;

    // True if reached this point
    return true;
  }
Пример #20
0
 void Split::spAdj(const pv_bvec_t& arg,
                   const pv_bvec_t& res, int* itmp, bvec_t* rtmp) {
   int nx = offset_.size()-1;
   for (int i=0; i<nx; ++i) {
     if (res[i]!=0) {
       bvec_t *arg_ptr = arg[0] + offset_[i];
       int n_i = sparsity(i).nnz();
       bvec_t *res_i_ptr = res[i];
       for (int k=0; k<n_i; ++k) {
         *arg_ptr++ |= *res_i_ptr;
         *res_i_ptr++ = 0;
       }
     }
   }
 }
Пример #21
0
  void Multiplication<TrX,TrY>::generateOperation(std::ostream &stream, const std::vector<std::string>& arg, const std::vector<std::string>& res, CodeGenerator& gen) const{
    // Check if inplace
    bool inplace = arg.at(0).compare(res.front())==0;

    // Copy first argument if not inplace
    if(!inplace){      
      stream << "  for(i=0; i<" << this->size() << "; ++i) " << res.front() << "[i]=" << arg.at(0) << "[i];" << endl;
    }

    // Perform sparse matrix multiplication
    gen.addAuxiliary(CodeGenerator::AUX_MM_TN_SPARSE);
    stream << "  casadi_mm_tn_sparse(";
    stream << arg.at(1) << ",s" << gen.getSparsity(dep(1).sparsity()) << ",";
    stream << arg.at(2) << ",s" << gen.getSparsity(dep(2).sparsity()) << ",";
    stream << res.front() << ",s" << gen.getSparsity(sparsity()) << ");" << endl;
  }
Пример #22
0
int main(int argc, char *argv[])
{
	// tests();
	// srand(time(10));
	srand(10);
	if(argc < 4)
	{
		std::cout << "Input arguments:\n\t1: Filename for A matrix (as in A ~= WH)\n\t2: New desired dimension\n\t3: Max NMF iterations\n\t4: Max NNLS iterations\n\t5 (optional): delimiter (space is default)\n";
	}
	else
	{
		std::string filename = argv[1];
		int newDimension = atoi(argv[2]);
		int max_iter_nmf = atoi(argv[3]);
		int max_iter_nnls = atoi(argv[4]);
		char delimiter = (argc > 5) ? *argv[5] : ' ';

		DenseMatrix* A = readMatrix(filename,delimiter);
		A->copyColumnToRow();
		printf("Sparsity of A: %f\n",sparsity(A));

		DenseMatrix W = DenseMatrix(A->rows,newDimension);
		DenseMatrix H = DenseMatrix(newDimension,A->cols);
		NMF_Input input = NMF_Input(&W,&H,A,max_iter_nmf,max_iter_nnls);

		std::cout << "Starting NMF computation." << std::endl;
		std::clock_t start = std::clock();
		double duration;
		// nmf_cpu(input);
		nmf_cpu_profile(input);
		duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
		std::cout << "NMF computation complete. Time: " << duration << " s." << std::endl;

		W.copyColumnToRow();
		dtype AF = FrobeniusNorm(A);
		dtype WH_AF = Fnorm(W,H,*A);
		printf("Objective value: %f\n",WH_AF/AF);
		// DenseMatrix z1 = DenseMatrix(A->rows,newDimension);
		// DenseMatrix z2 = DenseMatrix(newDimension,A->cols);
		// printf("Calculated solution approximate Frobenius norm: %f\n",Fnorm(z1,z2,*A));
		// printcolmajor(H.colmajor,H.rows,H.cols);
		if(A) delete A;
	}
	return 0;
}
Пример #23
0
void EvaluationMX::generateOperation(std::ostream &stream, const std::vector<std::string>& arg, const std::vector<std::string>& res, CodeGenerator& gen) const{
  
  // Get the index of the function
  int f = gen.getDependency(fcn_);
  stream << "  f" << f << "_buffered(";
  
  // Pass inputs to the function input buffers
  for(int i=0; i<arg.size(); ++i){
    // Pass argument to the function
    stream << arg.at(i) << ",";
    
    // Pass argument sparsity to the function
    if(dep(i).isNull()){
      stream << "0";
    } else {
      int sp_i = gen.getSparsity(dep(i).sparsity());
      stream << "s" << sp_i;
    }

    // Separate with a space to visualize argument grouping
    if(i+1<arg.size()+res.size()) stream << ", ";
  }

  // Separate arguments and results with two extra spaces
  stream << "  ";

  // Pass results to the function input buffers
  for(int i=0; i<res.size(); ++i){
    // Pass results buffer to the function
    stream << res.at(i) << ",";
    
    // Pass argument sparsity to the function
    int sp_i = gen.getSparsity(sparsity(i));
    stream << "s" << sp_i;

    // Separate with a space to visualize argument grouping
    if(i+1<res.size()) stream << ", ";
  }
  
  // Finalize the function call
  stream << ");" << endl;  
}
Пример #24
0
 void Project::spAdj(bvec_t** arg, bvec_t** res, int* iw, bvec_t* w) {
   dep().sparsity().bor(arg[0], res[0], sparsity());
   fill(res[0], res[0]+nnz(), 0);
 }
Пример #25
0
 void Project::generate(const std::vector<int>& arg, const std::vector<int>& res,
                          CodeGenerator& g) const {
   g.body << "  " << g.project(g.work(arg.front(), dep().nnz()), dep(0).sparsity(),
                               g.work(res.front(), nnz()), sparsity(), "w") << endl;
 }
Пример #26
0
  void SetNonzeros<Add>::eval_mx(const std::vector<MX>& arg, std::vector<MX>& res) {
    // Get all the nonzeros
    vector<int> nz = all();

    // Output sparsity
    const Sparsity &osp = sparsity();
    const int* orow = osp.row();
    vector<int> ocol = osp.get_col();

    // Input sparsity (first input same as output)
    const Sparsity &isp = dep(1).sparsity();
    vector<int> icol = isp.get_col();

    // We next need to resort the assignment vector by outputs instead of inputs
    // Start by counting the number of output nonzeros corresponding to each input nonzero
    vector<int> onz_count(osp.nnz()+2, 0);
    for (vector<int>::const_iterator it=nz.begin(); it!=nz.end(); ++it) {
      onz_count[*it+2]++;
    }

    // Cumsum to get index offset for output nonzero
    for (int i=0; i<onz_count.size()-1; ++i) {
      onz_count[i+1] += onz_count[i];
    }

    // Get the order of assignments
    vector<int> nz_order(nz.size());
    for (int k=0; k<nz.size(); ++k) {
      // Save the new index
      nz_order[onz_count[1+nz[k]]++] = k;
    }

    // Find out which elements are being set
    vector<int>& with_duplicates = onz_count; // Reuse memory
    onz_count.resize(nz.size());
    for (int k=0; k<nz.size(); ++k) {
      // Get output nonzero
      int onz_k = nz[nz_order[k]];

      // Get element (note: may contain duplicates)
      if (onz_k>=0) {
        with_duplicates[k] = ocol[onz_k]*osp.size1() + orow[onz_k];
      } else {
        with_duplicates[k] = -1;
      }
    }

    // Get all output elements (this time without duplicates)
    vector<int> el_output;
    osp.find(el_output);

    // Sparsity pattern being formed and corresponding nonzero mapping
    vector<int> r_colind, r_row, r_nz, r_ind;

    // Get references to arguments and results
    res[0] = arg[0];

    // Entries in res with elements zero'ed out
    if (!Add) {

      // Get the nz locations in res corresponding to the output sparsity pattern
      r_nz.resize(with_duplicates.size());
      copy(with_duplicates.begin(), with_duplicates.end(), r_nz.begin());
      res[0].sparsity().get_nz(r_nz);

      // Zero out the corresponding entries
      res[0] = MX::zeros(isp)->getSetNonzeros(res[0], r_nz);
    }

    // Get the nz locations of the elements in arg corresponding to the argument sparsity pattern
    arg[1].sparsity().find(r_nz);
    isp.get_nz(r_nz);

    // Filter out ignored entries and check if there is anything to add at all
    bool elements_to_add = false;
    for (vector<int>::iterator k=r_nz.begin(); k!=r_nz.end(); ++k) {
      if (*k>=0) {
        if (nz[*k]>=0) {
          elements_to_add = true;
        } else {
          *k = -1;
        }
      }
    }

    // Quick continue of no elements to set/add
    if (!elements_to_add) return;

    // Get the nz locations in the argument corresponding to the inputs
    r_ind.resize(el_output.size());
    copy(el_output.begin(), el_output.end(), r_ind.begin());
    res[0].sparsity().get_nz(r_ind);

    // Enlarge the sparsity pattern of the arguments if not all assignments fit
    for (vector<int>::iterator k=r_nz.begin(); k!=r_nz.end(); ++k) {
      if (*k>=0 && nz[*k]>=0 && r_ind[nz[*k]]<0) {

        // Create a new pattern which includes both the the previous seed
        // and the addition/assignment
        Sparsity sp = res[0].sparsity().unite(osp);
        res[0] = res[0]->getProject(sp);

        // Recalculate the nz locations in the arguments corresponding to the inputs
        copy(el_output.begin(), el_output.end(), r_ind.begin());
        res[0].sparsity().get_nz(r_ind);

        break;
      }
    }

    // Have r_nz point to locations in the result instead of the output
    for (vector<int>::iterator k=r_nz.begin(); k!=r_nz.end(); ++k) {
      if (*k>=0) {
        *k = r_ind[nz[*k]];
      }
    }

    // Add to the element to the sensitivity, if any
    res[0] = arg[1]->getAddNonzeros(res[0], r_nz);
  }
Пример #27
0
  void SetNonzeros<Add>::evalAdj(const std::vector<std::vector<MX> >& aseed,
                                 std::vector<std::vector<MX> >& asens) {
    // Get all the nonzeros
    vector<int> nz = all();

    // Number of derivative directions
    int nadj = aseed.size();

    // Output sparsity
    const Sparsity &osp = sparsity();
    const int* orow = osp.row();
    vector<int> ocol = osp.get_col();

    // Input sparsity (first input same as output)
    const Sparsity &isp = dep(1).sparsity();
    const int* irow = isp.row();
    vector<int> icol = isp.get_col();

    // We next need to resort the assignment vector by outputs instead of inputs
    // Start by counting the number of output nonzeros corresponding to each input nonzero
    vector<int> onz_count(osp.nnz()+2, 0);
    for (vector<int>::const_iterator it=nz.begin(); it!=nz.end(); ++it) {
      onz_count[*it+2]++;
    }

    // Cumsum to get index offset for output nonzero
    for (int i=0; i<onz_count.size()-1; ++i) {
      onz_count[i+1] += onz_count[i];
    }

    // Get the order of assignments
    vector<int> nz_order(nz.size());
    for (int k=0; k<nz.size(); ++k) {
      // Save the new index
      nz_order[onz_count[1+nz[k]]++] = k;
    }

    // Find out which elements are being set
    vector<int>& with_duplicates = onz_count; // Reuse memory
    onz_count.resize(nz.size());
    for (int k=0; k<nz.size(); ++k) {
      // Get output nonzero
      int onz_k = nz[nz_order[k]];

      // Get element (note: may contain duplicates)
      if (onz_k>=0) {
        with_duplicates[k] = ocol[onz_k]*osp.size1() + orow[onz_k];
      } else {
        with_duplicates[k] = -1;
      }
    }

    // Get all output elements (this time without duplicates)
    vector<int> el_output;
    osp.find(el_output);

    // Sparsity pattern being formed and corresponding nonzero mapping
    vector<int> r_colind, r_row, r_nz, r_ind;

    for (int d=0; d<nadj; ++d) {
      // Get the matching nonzeros
      r_ind.resize(el_output.size());
      copy(el_output.begin(), el_output.end(), r_ind.begin());
      aseed[d][0].sparsity().get_nz(r_ind);

      // Sparsity pattern for the result
      r_colind.resize(isp.size2()+1); // Col count
      fill(r_colind.begin(), r_colind.end(), 0);
      r_row.clear();

      // Perform the assignments
      r_nz.clear();
      for (int k=0; k<nz.size(); ++k) {

        // Get the corresponding nonzero for the input
        int el = nz[k];

        // Skip if zero assignment
        if (el==-1) continue;

        // Get the corresponding nonzero in the argument
        int el_arg = r_ind[el];

        // Skip if no argument
        if (el_arg==-1) continue;

        // Save the assignment
        r_nz.push_back(el_arg);

        // Get the corresponding element
        int i=icol[k], j=irow[k];

        // Add to sparsity pattern
        r_row.push_back(j);
        r_colind[1+i]++;
      }

      // col count -> col offset
      for (int i=1; i<r_colind.size(); ++i) r_colind[i] += r_colind[i-1];

      // If anything to set/add
      if (!r_nz.empty()) {
        // Create a sparsity pattern from vectors
        Sparsity f_sp(isp.size1(), isp.size2(), r_colind, r_row);
        asens[d][1] += aseed[d][0]->getGetNonzeros(f_sp, r_nz);
        if (!Add) {
          asens[d][0] += MX::zeros(f_sp)->getSetNonzeros(aseed[d][0], r_nz);
        } else {
          asens[d][0] += aseed[d][0];
        }
      } else {
        asens[d][0] += aseed[d][0];
      }
    }
  }
Пример #28
0
std::vector<MX> SymbolicMX::partial(const std::vector<MX>& x){
  return std::vector<MX>(1,MX::eye(sparsity().numel()));
}
Пример #29
0
 /** \brief Get required length of w field */
 virtual size_t sz_w() const { return sparsity().size1();}
Пример #30
0
 const std::vector<int>& SparseStorage<DataType>::row() const {
   return sparsity().row();
 }