min_max.h

Go to the documentation of this file.

#ifndef MIN_MAX_H
#define MIN_MAX_H

#include <itpp/base/mat.h>


namespace itpp
{


template<class T>
T max(const Vec<T> &v)
{
  T maxdata = v(0);
  for (int i = 1; i < v.length(); i++)
    if (v(i) > maxdata)
      maxdata = v(i);
  return maxdata;
}

template<class T>
T max(const Vec<T> &v, int& index)
{
  T maxdata = v(0);
  index = 0;
  for (int i = 1; i < v.length(); i++)
    if (v(i) > maxdata) {
      maxdata = v(i);
      index = i;
    }
  return maxdata;
}

template<class T>
Vec<T> max(const Mat<T> &m, int dim = 1)
{
  it_assert((dim == 1) || (dim == 2), "max(): dimension need to be 1 or 2");
  Vec<T> out;
  if (dim == 1) {
    out.set_size(m.cols(), false);
    for (int i = 0; i < m.cols(); i++)
      out(i) = max(m.get_col(i));
  }
  else {
    out.set_size(m.rows(), false);
    for (int i = 0; i < m.rows(); i++)
      out(i) = max(m.get_row(i));
  }
  return out;
}

template<class T>
Vec<T> max(const Mat<T> &m, ivec &index, int dim = 1)
{
  it_assert((dim == 1) || (dim == 2), "max(): dimension need to be 1 or 2");
  Vec<T> out;
  if (dim == 1) {
    out.set_size(m.cols(), false);
    index.set_size(m.cols(), false);
    for (int i = 0; i < m.cols(); i++)
      out(i) = max(m.get_col(i), index(i));
  }
  else {
    out.set_size(m.rows(), false);
    index.set_size(m.rows(), false);
    for (int i = 0; i < m.rows(); i++)
      out(i) = max(m.get_row(i), index(i));
  }
  return out;
}

template<class T>
T min(const Vec<T> &in)
{
  T mindata = in[0];
  for (int i = 1; i < in.length(); i++)
    if (in[i] < mindata)
      mindata = in[i];
  return mindata;
}

template<class T>
T min(const Vec<T> &in, int& index)
{
  T mindata = in[0];
  index = 0;
  for (int i = 1; i < in.length(); i++)
    if (in[i] < mindata) {
      mindata = in[i];
      index = i;
    }
  return mindata;
}


template<class T>
Vec<T> min(const Mat<T> &m, int dim = 1)
{
  it_assert((dim == 1) || (dim == 2), "min(): dimension need to be 1 or 2");
  Vec<T> out;
  if (dim == 1) {
    out.set_size(m.cols(), false);
    for (int i = 0; i < m.cols(); i++)
      out(i) = min(m.get_col(i));
  }
  else {
    out.set_size(m.rows(), false);
    for (int i = 0; i < m.rows(); i++)
      out(i) = min(m.get_row(i));
  }
  return out;
}


template<class T>
Vec<T> min(const Mat<T> &m,  ivec &index, int dim = 1)
{
  it_assert((dim == 1) || (dim == 2), "min(): dimension need to be 1 or 2");
  Vec<T> out;
  if (dim == 1) {
    out.set_size(m.cols(), false);
    index.set_size(m.cols(), false);
    for (int i = 0; i < m.cols(); i++)
      out(i) = min(m.get_col(i), index(i));
  }
  else {
    out.set_size(m.rows(), false);
    index.set_size(m.rows(), false);
    for (int i = 0; i < m.rows(); i++)
      out(i) = min(m.get_row(i), index(i));
  }
  return out;
}


template<class T>
int max_index(const Vec<T> &in)
{
  int maxindex = 0;
  for (int i = 1; i < in.length(); i++)
    if (in[i] > in[maxindex])
      maxindex = i;
  return maxindex;
}

template<class T>
void max_index(const Mat<T> &m, int &row, int &col)
{
  T maxdata = m(0, 0);
  row = col = 0;
  for (int i = 0; i < m.rows(); i++)
    for (int j = 0; j < m.cols(); j++)
      if (m(i, j) > maxdata) {
        row = i;
        col = j;
        maxdata = m(i, j);
      }
}

template<class T>
int min_index(const Vec<T> &in)
{
  int minindex = 0;
  for (int i = 1; i < in.length(); i++)
    if (in[i] < in[minindex])
      minindex = i;
  return minindex;
}

template<class T>
void min_index(const Mat<T> &m, int &row, int &col)
{
  T mindata = m(0, 0);
  row = col = 0;
  for (int i = 0; i < m.rows(); i++)
    for (int j = 0; j < m.cols(); j++)
      if (m(i, j) < mindata) {
        row = i;
        col = j;
        mindata = m(i, j);
      }
}

} //namespace itpp


#endif /* MIN_MAX_H */