field.cpp

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

}
// @(#)f_sum.C  1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


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



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



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


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



__field_node::__field_node(const __field_node& src) :
  length(src.length),
  ref_count(1)
{
  memcpy(data, src.data, sizeof(double)*length);
}
// @(#)fn_ct_ud.C       1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


__field_node::__field_node(size_t size, double fill) :
  length(size),
  ref_count(1)
{
  for (register i=0; i<size; i++) data[i] = fill;
}
// @(#)fn_eq.C  1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 



__field_node& __field_node::operator=(const __field_node& src){
  length = src.length;
  ref_count = 1;
  memcpy(data, src.data, sizeof(double)*length);
  return *this;
}
// @(#)fn_new.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


void* __field_node::operator new(size_t count, size_t length){
  assert(count == sizeof(__field_node));

RETRY:
  void* ptr = __field_alloc_Allocate(length*sizeof(double) + 
                                     sizeof(__field_node));

  if (!ptr){
    __field_alloc_collect_garbage();
    goto RETRY;
  }
  return ptr;
}
void* __field_node::operator new(size_t count){
    return __field_node::operator new( count, 1 );
}

void __field_node::operator delete(void* ptr){
  __field_alloc_Deallocate(ptr);
}
// @(#)i_abs.C  1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 



ifield abs(const ifield& f){
  size_t l = f.root->length;
  ifield rtn(l);
  for (register i=0; i<l; i++) 
    rtn.root->data[i] = (f.root->data[i] < 0?  -f.root->data[i] :
                                                f.root->data[i]);
  return rtn;
}
// @(#)i_assem_1.C      1.2   Release Date: 2/19/93


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

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


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

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


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

// @(#)i_band_d.C       1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


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


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


ifield& ifield::operator&=(const ifield& 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;
}
// @(#)i_band_fd.C      1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


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


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


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


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


ifield& ifield::operator|=(const ifield& 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;
}
// @(#)i_bor_fd.C       1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


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


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


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



ifield::ifield(size_t len_a, const INT *a) :
  ref_flag(0),
  root(new(len_a) __field_inode(len_a))
{
  memcpy(root->data, a, sizeof(*a)*len_a);
}
// @(#)i_ct_f.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


ifield::ifield(const ifield& f) :
  ref_flag(0)
{
  if (!f.root){
    root = NULL;
  }else if (f.ref_flag){
    root = f.root->NewCopy();
  }else{
    root = f.root;
    f.root->ref_count++;
  }
}
// @(#)i_di_d.C 1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


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


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


ifield& ifield::operator/=(const ifield& 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;
}
// @(#)i_di_fd.C        1.1   Release Date: 2/19/93
//       Author:  Kent G. Budge, 
//                Computational Physics Research and Development (1431)
//                Sandia National Laboratories 


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


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


ifield dim(INT a, const ifield& b){
  const size_t l = b.Length();
  ifield rtn(l);
  for (register i=0; i<l; i++)  rtn[i] = (a > b[i]? a - b[i] : 0);
  return rtn;
}

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


ifield dim(const ifield& a, INT b){
  const size_t l = a.Length();
  ifield rtn(l);
  for (register i=0; i<l; i++)  rtn[i] = (a[i] > b? a[i] - b : 0);
  return rtn;
}

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


ifield dim(const ifield& a, const ifield& b){
  const size_t l = a.Length();
  assert(l == b.Length());
  ifield rtn(l);
  for (register i=0; i<l; i++)  rtn[i] = (a[i] > b[i]? a[i] - b[i] : 0);
  return rtn;
}

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



void div(int a, const ifield& b, ifield& c, ifield& d){
  const size_t l = b.Length();
  c = ifield(l);
  d = ifield(l);
  for (register i=0; i<l; i++){
    c[i] = a/b[i];
    d[i] = a%b[i];
  }
}

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