---

real_parameter.cc

Go to the documentation of this file.

// real_parameter.cc
// SuperMix version 1.0  C++ source file
//
// Copyright (c) 1999 California Institute of Technology.
// All rights reserved.
//
// Redistribution and use in source and binary forms for noncommercial
// purposes are permitted provided that the above copyright notice and
// this paragraph are duplicated in all such forms and that any
// documentation and other materials related to such distribution and
// use acknowledge that the software was developed by California
// Institute of Technology. Redistribution and/or use in source or
// binary forms is not permitted for any commercial purpose. Use of
// this software does not include a permitted use of the Institute's
// name or trademark for any purpose.
//
// DISCLAIMER:
// THIS SOFTWARE AND/OR RELATED MATERIALS ARE PROVIDED "AS-IS" WITHOUT
// WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE (AS SET
// FORTH IN UCC 23212-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
// LICENSED PRODUCT, HOWEVER USED.  IN NO EVENT SHALL CALTECH/JPL BE
// LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING BUT NOT LIMITED TO
// INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, INCLUDING ECONOMIC
// DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF
// WHETHER CALTECH/JPL SHALL BE ADVISED, HAVE REASON TO KNOW, OR IN
// FACT SHALL KNOW OF THE POSSIBILITY.  THE USER BEARS ALL RISK
// RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND/OR RELATED
// MATERIALS.
//
// Change history:
// 8/19/98:  Fixed default operator =

#include "parameter/real_parameter.h"
#include "global.h"
#include "error.h"


// default constructor
real_parameter::real_parameter(double v) :
  value(v),
  shadowed(0),
  get_flag(false),
  use_min(false), min(0.0),
  use_max(false), max(0.0)
{ }

real_parameter::real_parameter(int v) :
  value(double(v)),
  shadowed(0),
  get_flag(false),
  use_min(false), min(0.0),
  use_max(false), max(0.0)
{ }

// shadow another parameter
real_parameter::real_parameter(const abstract_real_parameter *p) :
  value(0.0),
  shadowed(p),
  get_flag(false),
  use_min(false), min(0.0),
  use_max(false), max(0.0)
{
  if (p == 0) {
    error::warning("real_parameter constructor: " 
                   "Null pointer passed to constructor; not shadowing.");
  }
}

double real_parameter::get() const
{
  if (is_local()) return value;

  else {

    // if shadow loop brings us back to this object, we quit indirecting
    if(get_flag) {
      get_flag = false;  // reset it for next time
      error::warning("real_parameter::get(): Terminating infinite" 
                     " shadowing loop, returning zero.");
      return 0.0;
    }

    // use indirection through the shadowing pointer
    get_flag = true;
    double v = shadowed->get();
    get_flag = false;

    return limit(v);
  }
}

real_parameter & real_parameter::shadow(const abstract_real_parameter &p)
{
  // do nothing in case argument is this object
  if (&p == this) {
    error::warning("real_parameter::shadow(): a real_parameter must not shadow itself.");
  }
  else {
    shadowed = &p;
  }
  return *this;
}

real_parameter & real_parameter::set_min(double m)
{
  if(use_max && m >= max) {
    error::warning("real_parameter::set_min(): minimum should be"
                   " less than real_parameter maximum.");
    m = max;
  }

  use_min = true;
  min = m;
  if(is_local() && value < min) value = min;
  return *this;
}

real_parameter & real_parameter::set_max(double m)
{
  if(use_min && m <= min) {
    error::warning("real_parameter::set_max(): maximum should be"
                   " greater than real_parameter minimum.");
    m = min;
  }

  use_max = true;
  max = m;
  if(is_local() && value > max) value = max;
  return *this;
}

real_parameter& real_parameter::operator=(const abstract_real_parameter *p)
{
  if(p == 0) {
    error::warning("real_parameter assignment: Cannot set real_parameter"
                   " to shadow a null pointer !") ;
    return *this;
  }
  else return shadow(*p);
}

real_parameter& real_parameter::clone(const real_parameter & p)
{
  // do nothing in case argument is this object or directly shadows this object
  if (&p == this || p.shadowed == this) return *this;

  // make an identical twin of the argument
  value = p.value;
  shadowed = p.shadowed;
  use_min = p.use_min;
  min = p.min;
  use_max = p.use_max;
  max = p.max;

  return *this;
}

istream &operator >>(istream & in_file, real_parameter & p)
{
  double temp;
  in_file >> temp;
  p.set(temp);
  return in_file;
}

---

Please direct comments and corrections to supermix@submm.caltech.edu
Go to the supermix home page
Generated by 1.2.7