field.cpp

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C++ 代码 · 共 2,240 行 · 第 1/5 页

  for (register i=0; i<l; i++)
    rtn.root->data[i] = (a.root->data[i] > b.root->data[i] ?
                                a.root->data[i] : b.root->data[i]);
  return rtn;
}
// @(#)f_mi_d.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field& field::operator-=(double d){
  assert(root!=NULL);
  Private();
  size_t l = root->length;
  for (register i=0; i<l; i++) root->data[i] -= d;
  return *this;
}
// @(#)f_mi_df.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator-(double d, const field& a){
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = d - a.root->data[i];
  return rtn;
}
// @(#)f_mi_f.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field& field::operator-=(const field& f){
  assert(root && f.root && root->length == f.root->length);
  Private();
  size_t l = root->length;
  for (register i=0; i<l; i++) root->data[i] -= f.root->data[i];
  return *this;
}
// @(#)f_mi_fd.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator-(const field& a, double d){
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = a.root->data[i] - d;
  return rtn;
}
// @(#)f_mi_ff.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator-(const field& a, const field& b){
  assert(a.root->length == b.root->length);
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) 
    rtn.root->data[i] = a.root->data[i] - b.root->data[i];
  return rtn;
}
// @(#)f_min_df.C       1.1   Release Date: 2/19/93



field min(double b, const field& a){
  size_t l = a.Length();
  field rtn(l);
  for (register i=0; i<l; i++)
    rtn.root->data[i] = (a.root->data[i] < b? a.root->data[i] : b);
  return rtn;
}
// @(#)f_min_f.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


double min(const field& f){
  size_t l = f.root->length;
  double retval = f.root->data[l-1];
  for (register i=0; i<l-1; i++) 
    retval = (retval < f.root->data[i]? retval : f.root->data[i]);
  return retval;
} 
// @(#)f_min_fd.C       1.1   Release Date: 2/19/93



field min(const field& a, double b){
  size_t l = a.Length();
  field rtn(l);
  for (register i=0; i<l; i++)
    rtn.root->data[i] = (a.root->data[i] < b? a.root->data[i] : b);
  return rtn;
}
// @(#)f_min_ff.C       1.1   Release Date: 2/19/93



field min(const field& a, const field& b){
  size_t l = a.Length();
  assert(l == b.root->length);
  field rtn(l);
  for (register i=0; i<l; i++)
    rtn.root->data[i] = (a.root->data[i] < b.root->data[i] ?
                                a.root->data[i] : b.root->data[i]);
  return rtn;
}
// @(#)f_modf.C 1.2   Release Date: 2/19/93



field modf(const field& a, field& b){
  size_t l = a.Length();
  field rtn(l);
  b = field(l);
  double *rp = rtn, *bp = b;
  const double *ap = a;
  for (register i=0; i<l; i++) rp[i] = modf(ap[i], bp + i);
  return rtn;
}
// @(#)f_mu_d.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field& field::operator*=(double d){
  assert(root!=NULL);
  Private();
  size_t l = root->length;
  for (register i=0; i<l; i++) root->data[i] *= d;
  return *this;
}
// @(#)f_mu_df.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator*(double d, const field& a){
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = d * a.root->data[i];
  return rtn;
}
// @(#)f_mu_f.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field& field::operator*=(const field& f){
  assert(root && f.root && root->length == f.root->length);
  Private();
  size_t l = root->length;
  for (register i=0; i<l; i++) root->data[i] *= f.root->data[i];
  return *this;
}
// @(#)f_mu_fd.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator*(const field& a, double d){
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = a.root->data[i] * d;
  return rtn;
}
// @(#)f_mu_ff.C        1.2   Release Date: 3/1/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator*(const field& a, const field& b){
  assert(a.root->length == b.root->length);
  const size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) 
    rtn.root->data[i] = a.root->data[i] * b.root->data[i];
  return rtn;
}
// @(#)f_pf.C   1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


void field::Free(void) {
  if (root && !(--root->ref_count)){
    delete root;
  }
  root = 0;
}

void field::Private(void) {
  if (root && root->ref_count > 1){
    __field_node* tmp = root->NewCopy();
    Free();
    root = tmp;
  }
}
// @(#)f_pl_d.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field& field::operator+=(double d){
  assert(root!=NULL);
  Private();
  size_t l = root->length;
  for (register i=0; i<l; i++) root->data[i] += d;
  return *this;
}
// @(#)f_pl_df.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator+(double d, const field& a){
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = d + a.root->data[i];
  return rtn;
}
// @(#)f_pl_f.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field& field::operator+=(const field& f){
  assert(root && f.root && root->length == f.root->length);
  Private();
  size_t l = root->length;
  for (register i=0; i<l; i++) root->data[i] += f.root->data[i];
  return *this;
}
// @(#)f_pl_fd.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator+(const field& a, double d){
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = a.root->data[i] + d;
  return rtn;
}
// @(#)f_pl_ff.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


field operator+(const field& a, const field& b){
  assert(a.root->length == b.root->length);
  size_t l = a.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) 
    rtn.root->data[i] = a.root->data[i] + b.root->data[i];
  return rtn;
}
// @(#)f_pow_df.C       1.1   Release Date: 2/19/93



field pow(double a, const field& b){
  size_t l = b.Length();
  field rtn(l);
  double *rp = rtn;
  const double *bp = b;
  for (register i=0; i<l; i++) rp[i] = pow(a, bp[i]);
  return rtn;
}
// @(#)f_pow_fd.C       1.1   Release Date: 2/19/93



field pow(const field& a, double b){
  size_t l = a.Length();
  field rtn(l);
  double *rp = rtn;
  const double *ap = a;
  for (register i=0; i<l; i++) rp[i] = pow(ap[i], b);
  return rtn;
}
// @(#)f_pow_ff.C       1.1   Release Date: 2/19/93



field pow(const field& a, const field& b){
  size_t l = a.root->length;
  assert(b.root->length == l);
  field rtn(l);
  for (register i=0; i<l; i++) 
    rtn.root->data[i] = pow(a.root->data[i], b.root->data[i]);
  return rtn;
}
// @(#)f_scatter_1.C    1.2   Release Date: 2/19/93


field& field::Scatter(const field& b, const ifield& ia, const ifield& ib){
  size_t l = ia.Length();
  assert (l = ib.Length());
  double *This = *this;
  const double *bp = b;
  const INT *iap = ia, *ibp = ib;
  for (register i=0; i<l; i++)  This[iap[i]] = bp[ibp[i]];
  return *this;
}
// @(#)f_scatter_2.C    1.1   Release Date: 2/19/93



field& field::Scatter(const field& b, const ifield& ia){
  const size_t l = ia.Length();
  assert(l == b.Length());
  field& This = *this;
  for (register i=0; i<l; i++)  This[ia[i]] = b[i];
  return This;
}

// @(#)f_scatter_3.C    1.1   Release Date: 2/19/93



field& field::Scatter(double b, const ifield& ia){
  const size_t l = ia.Length();
  field& This = *this;
  for (register i=0; i<l; i++)  This[ia[i]] = b;
  return This;
}

// @(#)f_scatter_4.C    1.2   Release Date: 2/19/93


field& field::Scatter(const field& a, size_t start, size_t end, size_t stride){
  assert(end < root->length);
  assert((end-start)/stride < a.root->length);
  double *This = *this;
  const double *ap = a;
  for (register i=start, j=0; i<end; i+=stride,j++)  This[i] = ap[j];
  return *this;
}
// @(#)f_shift.C        1.2   Release Date: 2/26/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 



field field::Shift(int i) const{
  size_t l = root->length;
  field rtn(l);
  if (i>=0) memcpy(rtn.root->data+1, root->data, (l-i)*sizeof(double));
       else memcpy(rtn.root->data, root->data-i, (l+i)*sizeof(double));
  return rtn;
}
// @(#)f_sign_df.C      1.1   Release Date: 2/19/93



field sign(double b, const field& a){
  size_t l = a.Length();
  field rtn(l);
  for (register i=0; i<l; i++)
    rtn.root->data[i] = (a.root->data[i] < 0.0? -b : b);
  return rtn;
}
// @(#)f_sign_fd.C      1.2   Release Date: 2/19/93



field sign(const field& a, double b){
  size_t l = a.Length();
  field rtn(l);
  double *rp = rtn;
  const double *ap = a;
  for (register i=0; i<l; i++) rp[i] = (b<0.0? -ap[i] : ap[i]);
  return rtn;
}
// @(#)f_sign_ff.C      1.1   Release Date: 2/19/93



field sign(const field& a, const field& b){
  size_t l = a.Length();
  assert(l == b.root->length);
  field rtn(l);
  for (register i=0; i<l; i++)
    rtn.root->data[i] = (b.root->data[i] < 0.0? -a.root->data[i] :
                                                 a.root->data[i]);
  return rtn;
}
// @(#)f_sin.C  1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 



field sin(const field& f){
  size_t l = f.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = sin(f.root->data[i]);
  return rtn;
}
// @(#)f_sinh.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 



field sinh(const field& f){
  size_t l = f.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = sinh(f.root->data[i]);
  return rtn;
}
// @(#)f_sqrt.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 



field sqrt(const field& f){
  size_t l = f.root->length;
  field rtn(l);
  for (register i=0; i<l; i++) rtn.root->data[i] = sqrt(f.root->data[i]);
  return rtn;