qfrontend.cpp

算断裂的

  return returnval;
}

vector<QMG::string>
QMG::FrontEnd::ArgValType::get_vector_string(int argidx) const {
#ifdef RANGECHECK
  if (argidx < 0 || argidx >= nrhs_)
    throw_error("Argidx range error vs");
#endif
  if (!mxIsCell(prhs_[argidx])) {
    ostringstream os;
    os << "Argument #" << argidx << " should be a cell array of strings";
    throw_error(os.str());
  }
  int sz = mxGetM(prhs_[argidx]) * mxGetN(prhs_[argidx]);
  vector<string> returnval;
  for (int j = 0; j < sz; ++j) {
    const mxArray* cell = mxGetCell(prhs_[argidx], j);
    if (cell == 0)
      throw_error("Unable to retrieve cell");
    if (!mxIsChar(cell)) {
      ostringstream os;
      os << "Entry " << j+1 << " of argument #" << argidx << " should be a string";
      throw_error(os.str());
    }
    int l = mxGetM(cell) * mxGetN(cell);
    char* buf = new char[l + 2];
    mxGetString(cell, buf, l + 1);
    returnval.push_back(string(buf));
    delete[] buf;
  }
  return returnval;
}




QMG::Matrix
QMG::FrontEnd::ArgValType::get_matrix(int argidx) const {
#ifdef RANGECHECK
  if (argidx < 0 || argidx >= nrhs_)
    throw_error("Argidx range error 6m");
#endif
  if (!mxIsDouble(prhs_[argidx]) || mxIsSparse(prhs_[argidx]) ||
      mxGetPi(prhs_[argidx])) {
    ostringstream ostr;
    ostr << "Argument #" << argidx << " is supposed to be a double matrix";
    throw_error(ostr.str());
  }
  int nr = mxGetM(prhs_[argidx]);
  int nc = mxGetN(prhs_[argidx]);
  Matrix m(nr,nc);
  const double* pr = mxGetPr(prhs_[argidx]);
  for (int i = 0; i < nr; ++i)
    for (int j = 0; j < nc; ++j)
      m(i,j) = pr[i + j * nr];
  return m;
}

QMG::Matrix
QMG::FrontEnd::ArgValType::get_zbamatrix(int argidx) const {
#ifdef RANGECHECK
  if (argidx < 0 || argidx >= nrhs_)
    throw_error("Argidx range error 6m");
#endif
  const mxArray* obj = prhs_[argidx];
  if (strcmp(mxGetClassName(obj), "zba") != 0)
    throw_error("Input integer matrix not of class zba");
  const mxArray* entries = mxGetFieldByNumber(obj, 0, 0);
  if (entries == 0)
    throw_error("Input integer matrix has no field 0 (not a brep)");
  if (!mxIsDouble(entries) || mxIsSparse(entries) ||
      mxGetPi(entries)) {
    ostringstream ostr;
    ostr << "Argument #" << argidx << " is supposed to be a double matrix";
    throw_error(ostr.str());
  }
  int nr = mxGetM(entries);
  int nc = mxGetN(entries);
  Matrix m(nr,nc);
  const double* pr = mxGetPr(entries);
  for (int i = 0; i < nr; ++i)
    for (int j = 0; j < nc; ++j)
      m(i,j) = pr[i + j * nr];
  return m;
}


QMG::IntMatrix
QMG::FrontEnd::ArgValType::get_intmatrix(int argidx) const {
#ifdef RANGECHECK
  if (argidx < 0 || argidx >= nrhs_)
    throw_error("Argidx range error 6mi");
#endif
  const mxArray* entries = prhs_[argidx];
  if (entries == 0)
    throw_error("Input integer matrix has no field 0 (not a brep)");
  if (!mxIsDouble(entries) || mxIsSparse(entries) ||
      mxGetPi(entries)) {
    ostringstream ostr;
    ostr << "Argument #" << argidx << " is supposed to be a dense int matrix";
    throw_error(ostr.str());
  }
  int nr = mxGetM(entries);
  int nc = mxGetN(entries);
  IntMatrix m(nr,nc);
  const double* pr = mxGetPr(entries);
  for (int i = 0; i < nr; ++i)
    for (int j = 0; j < nc; ++j) {
      double d = pr[i + j * nr];
      int dint = static_cast<int>(d);
      if (d != static_cast<double>(dint)) {
	ostringstream ostr;
	ostr << "Entry " << i+1 << "," << j+1 << " of argument #" << 
	  argidx << " is nonintegral";
	throw_error(ostr.str());
      }
      m(i,j) = dint;
    }
  return m;
}




QMG::FrontEnd::ReturnValType::ReturnValType(int nlhs, mxArray** plhs) {
  nlhs_ = nlhs;
  plhs_ = plhs;
}

QMG::FrontEnd::ReturnValType::~ReturnValType() {
}

void 
QMG::FrontEnd::ReturnValType::verify_nargout(int nargoutmin, 
                                             int nargoutmax, 
                                             const char* routine_name) {
  if (nlhs_ < nargoutmin || nlhs_ > nargoutmax) {
    ostringstream os;
    os << "Wrong number of output arguments to " << routine_name 
       << "; expected " << nargoutmin << " to " << nargoutmax;
    throw_error(os.str());
  }
  if (nlhs_ == 0 && nargoutmax > 0)
    nlhs_ = 1;
}

void QMG::FrontEnd::ReturnValType::checkarg_(int idx) {
  if (idx < 0 || idx >= nlhs_) 
    throw_error("returnval put called for index out of range");
}


int QMG::FrontEnd::ReturnValType::nargout() const {
  return nlhs_;
}


void 
QMG::FrontEnd::ReturnValType::put_simpcomp(int argidx, SimpComplex_Under_Construction& sc) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  plhs_[argidx] = sc.release();
}

void 
QMG::FrontEnd::ReturnValType::put_brep(int argidx, Brep_Under_Construction& b) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif

  mxArray* gtmp = b.release();
  plhs_[argidx] = gtmp;
}

void 
QMG::FrontEnd::ReturnValType::put_double(int argidx, double val) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  plhs_[argidx] = mxCreateDoubleMatrix(1, 1, mxREAL);
  *mxGetPr(plhs_[argidx]) = val;
}

void 
QMG::FrontEnd::ReturnValType::put_int(int argidx, int val) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  plhs_[argidx] = mxCreateDoubleMatrix(1, 1, mxREAL);
  *mxGetPr(plhs_[argidx]) = static_cast<double>(val);
}




void 
QMG::FrontEnd::ReturnValType::put_matrix(int argidx, Matrix& m) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  int nr = m.numrows();
  int nc = m.numcols();
  plhs_[argidx] = mxCreateDoubleMatrix(nr, nc, mxREAL);
  double* pr = mxGetPr(plhs_[argidx]);
  for (int i = 0; i < nr; ++i)
    for (int j = 0; j < nc; ++j)
      pr[i + j * nr] = m(i,j);
}

void 
QMG::FrontEnd::ReturnValType::put_intmatrix(int argidx, IntMatrix& m) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  int nr = m.numrows();
  int nc = m.numcols();
  plhs_[argidx] = mxCreateDoubleMatrix(nr, nc, mxREAL);
  double* pr = mxGetPr(plhs_[argidx]);
  for (int i = 0; i < nr; ++i)
    for (int j = 0; j < nc; ++j)
      pr[i + j * nr] = static_cast<double>(m(i,j));
}

void 
QMG::FrontEnd::ReturnValType::put_intvector(int argidx, vector<int>& m) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  mxArray* plhsa[1];
  mxArray* prhsa[1];
  mexCallMATLAB(1,plhsa,0, prhsa, "zba");
  mxArray* zba = plhsa[0];
  mxArray* oldentries = mxGetFieldByNumber(zba,0, 0);
  if (oldentries)
    mxFree(oldentries);
  int nr = m.size();
  mxArray* data1  = mxCreateDoubleMatrix(nr, 1, mxREAL);
  double* pr = mxGetPr(data1);
  for (int i = 0; i < nr; ++i)
    pr[i] = static_cast<double>(m[i]);
  mxSetFieldByNumber(zba,0,0,data1);
  plhs_[argidx] = zba;
}

void 
QMG::FrontEnd::ReturnValType::put_string(int argidx, const string& s) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  int nr = s.length();
  plhs_[argidx] = mxCreateString(s.c_str());
}


void 
QMG::FrontEnd::ReturnValType::put_doublevector(int argidx, vector<double>& m) {
#ifdef DEBUGGING
  checkarg_(argidx);
#endif
  int nr = m.size();
  plhs_[argidx] = mxCreateDoubleMatrix(nr, 1, mxREAL);
  double* pr = mxGetPr(plhs_[argidx]);
  for (int i = 0; i < nr; ++i)
    pr[i] = m[i];
}



QMG::FrontEnd::InterpOStream::InterpOStream(Interpreter&) :
sb_(0), os_(0) {
  sb_ = new MatlabStreambuf;
  os_ = new QMG::ostream(sb_);
}

QMG::FrontEnd::InterpOStream::~InterpOStream() {
  if (os_) delete os_;
  if (sb_) delete sb_;
}


// ------------------------------------------------------------------
// default_tol
// get the default tolerance from global variable gm_default_tol
// ------------------------------------------------------------------

double QMG::FrontEnd::default_tol(Interpreter&) {
  const mxArray* gm_default_tola = 
    mexGetArrayPtr("GM_DEFAULT_TOL", "global");
  if (!gm_default_tola) {
    default_tol_errmsg1();
    throw_error("GM_DEFAULT_TOL global variable absent");
  }
  if (!mxIsDouble(gm_default_tola) || mxIsSparse(gm_default_tola)
      || mxGetPi(gm_default_tola) ||
      mxGetM(gm_default_tola) * mxGetN(gm_default_tola) != 1) {
    default_tol_errmsg1();
    throw_error("GM_DEFAULT_TOL global variable wrong type");
  }
  double x = *mxGetPr(gm_default_tola);
  if (x <= 0 || x > 1) {
    default_tol_errmsg1();
    throw_error("GM_DEFAULT_TOL out of range");
  }
  return x;
}