util.h

Go to the documentation of this file.

/*!
  \file   util.h
  \author Klaus Holst
  \date   Jan 2005
  
  \brief  Misc. utility-functions.
    
*/

#ifndef _UTIL_H_
#define _UTIL_H_

#include <cassert>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include "debug.h"
//#include <ncurses.h>
//#include <curses.h>


template <class Real> 
Real sum(safevector<Real> xx) {
  Real res=0;
   for (unsigned i=0; i<xx.size(); i++) {
     res += xx[i];
   }
   return res;
}

template <class Real>
safevector<Real> cumsum(safevector<Real> xx) {
  safevector<Real> res(xx.size());
  Real cumsum = 0;
  for (unsigned i=0; i<xx.size(); i++) {
    cumsum += xx[i];
    res[i] = cumsum;
  }
  return res;
}

inline double num(double x) {                                 //numerisk værdi
  double y=x;
  if (x < 0)
    y = -x;
  return(y);
}


inline int imin(int a, int b) {
  if (a<b) return(a);
  else return(b);
}

inline int imax(int a, int b)
{
  if (a>b) return(a);
  else return(b);
}

void error(char* error_text);

template <class T>
std::string numStr(T x) {
  std::ostringstream nmbstr; nmbstr << x;
  std::string ss = nmbstr.str();    

//   char buffer[32];
//   sprintf(buffer, "%03d", n);
//   return buffer;

  return ss;
}


template <class T>
safevector<T> concat(safevector<T> const& a, safevector<T> const& b) {
  safevector<T> c = a;
  c.insert(c.end(), b.begin(), b.end());
  return c;
}

safevector<double> interval(double start, double stop, double step = 1.0);
safevector<float> getparm(std::string const& strval);

template <class A, class B>
  std::ostream& operator<<(std::ostream& out, std::pair<A,B> const& ab) {
  out << '(' << ab.first << ", " << ab.second << ')';
  return out;
}

template <typename T>
std::ostream& operator<<(std::ostream& out, 
                         safevector< safevector<T> > const& m) {
  out.setf(std::ios::fixed);
  out.precision(15); // Perhaps setting precision should be moved
                     // elsewhere.

  out << '[';
  for(unsigned y=0; y<m.size(); ++y) {
    if(y > 0) out << std::endl << ";...\n";
    
    for(int x = 0; x < (int)m[y].size(); ++x) {
      if(x > 0) out << ", ";
      out << m[y][x];
    }
  }
  out << ']';
  return out;
}

template <typename T>
std::istream& operator>>(std::istream& in, 
                         safevector< safevector<T> >& m) throw(std::string) {
  char c;
  in >> c;
  if(in.fail() || c != '[') 
    throw std::string("Expected '[' as matrix start");

  typedef safevector<T> Line;
  safevector<Line> lines;
  Line line;

  for(;;) {
    T value;
    std::string token;
    
    in >> value >> token;
    if(in.fail()) throw std::string("Format error when reading matrix.");
    
    line.push_back(value);
    if(token == ";" || token == ";..." ||
       token == "]" || token == "];") {
      if(lines.size() >= 1 && 
         lines[0].size() != line.size())
        throw std::string("All matrix rows must have the same size.");
      
      lines.push_back(line);
      line = Line();

      if(token[0] == ']') break;

    } else if(token != ",") {
      throw std::string("Invalid matrix element delimiter: ") + token;
    }
  }   
  m = lines;
  return in;
}

template <class T>
std::ostream& operator<<(std::ostream& out, std::vector<T> const& xx) {
  out << '[';
  for(unsigned i = 0; i < xx.size(); ++i) {
    out << xx[i];
    if(i + 1 < xx.size()) out << ", ";
  }
  out << ']';
  return out;
}

#endif

---