defs.h

Go to the documentation of this file.

/* 
 * Scythe Statistical Library
 * Copyright (C) 2000-2002 Andrew D. Martin and Kevin M. Quinn;
 * 2002-present Andrew D. Martin, Kevin M. Quinn, and Daniel
 * Pemstein.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * under the terms of the GNU General Public License as published by
 * Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.  See the text files COPYING
 * and LICENSE, distributed with this source code, for further
 * information.
 * --------------------------------------------------------------------
 * scythestat/defs.h
 */

/* Doxygen main page text */
#ifndef SCYTHE_DEFS_H
#define SCYTHE_DEFS_H

/* In many functions returning matrices, we want to allow the user to
 * get a matrix of any style, but want to work with concretes inside
 * the function, for efficiency.  This macro originally contained the
 * code:
 * 
 * if (_STYLE_ == View)                                                \
 *   return Matrix<_TYPE_,_ORDER_,View>(_MATRIX_);                     \
 * else                                                                \
 *   return _MATRIX_;
 *
 * to convert to View before return if necessary.  Of course, this is
 * completely redundant, since the copy constructor gets called on
 * return anyway, so the body of the macro was replaced with a simple
 * return.  If we change our minds down the road about how to handle
 * these returns, code changes will be centered on this macro.
 */
#define SCYTHE_VIEW_RETURN(_TYPE_, _ORDER_, _STYLE_, _MATRIX_)        \
    return _MATRIX_;

/* Some macros to do bounds checking for iterator accesses.  The first
 * two are only called by the [] operator in the random access
 * iterator.  The third macro handles everything for checks on simple
 * current iterator location accesses.
 */
#define SCYTHE_ITER_CHECK_POINTER_BOUNDS(POINTER)                     \
{                                                                     \
  SCYTHE_CHECK_30(POINTER >= start_ + size_ || POINTER < start_,      \
    scythe_bounds_error, "Iterator access (offset "                   \
    << offset_ << ") out of matrix bounds")                           \
}

#define SCYTHE_ITER_CHECK_OFFSET_BOUNDS(OFFSET)                       \
{                                                                     \
  SCYTHE_CHECK_30(OFFSET >= size_, scythe_bounds_error,               \
    "Iterator access (offset " << offset_ << ") out of matrix bounds")\
}

#define SCYTHE_ITER_CHECK_BOUNDS()                                    \
{                                                                     \
  if (M_STYLE != Concrete || M_ORDER != ORDER) {                      \
    SCYTHE_ITER_CHECK_OFFSET_BOUNDS(offset_);                         \
  } else {                                                            \
    SCYTHE_ITER_CHECK_POINTER_BOUNDS(pos_);                           \
  }                                                                   \
}

namespace scythe {

  enum matrix_order { Col, Row };

  enum matrix_style { Concrete, View };

  struct all_elements {
  } const _ = {};

  // A little helper method to see if more col-order or row-order.
  // Tie breaks towards col.
  template <matrix_order o1, matrix_order o2, matrix_order o3>
  bool maj_col()
  {
    if ((o1 == Col && o2 == Col) ||
        (o1 == Col && o3 == Col) ||
        (o2 == Col && o3 == Col))
      return true;
    return false;
  }

  template <matrix_order o1, matrix_order o2, matrix_order o3,
            matrix_order o4>
  bool maj_col()
  {
    if ((o1 == Col && o2 == Col) ||
        (o1 == Col && o3 == Col) ||
        (o1 == Col && o4 == Col) ||
        (o2 == Col && o3 == Col) ||
        (o2 == Col && o4 == Col) ||
        (o3 == Col && o4 == Col))
      return true;
    return false;
  }
}  // end namespace scythe

#endif /* SCYTHE_ERROR_H */