m_reduce.h

Go to the documentation of this file.

/* Copyright (C) 2014 Richard Larsson <ric.larsson@gmail.com>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */
 
#ifndef m_reduce_h
#define m_reduce_h
 
#include <cstring>
#include "array.h"
#include "exceptions.h"
#include "matpackVII.h"
 
 
inline Index num_elem_from_dim_sizes(const ArrayOfIndex& dim_sizes) {
  Index m = 1;
  for (ArrayOfIndex::const_iterator it = dim_sizes.begin();
       it != dim_sizes.end();
       it++)
    m *= *it;
 
  return m;
}
 
// Need this for each matpack type: Vector
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Vector& type) {
  dim_sizes.resize(0);
  if (type.nelem() > min_num_elem) dim_sizes.push_back(type.nelem());
}
 
// Need this for each matpack type: Matrix
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Matrix& type) {
  dim_sizes.resize(0);
  if (type.nrows() > min_num_elem) dim_sizes.push_back(type.nrows());
  if (type.ncols() > min_num_elem) dim_sizes.push_back(type.ncols());
}
 
// Need this for each matpack type: Tensor3
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Tensor3& type) {
  dim_sizes.resize(0);
  if (type.npages() > min_num_elem) dim_sizes.push_back(type.npages());
  if (type.nrows() > min_num_elem) dim_sizes.push_back(type.nrows());
  if (type.ncols() > min_num_elem) dim_sizes.push_back(type.ncols());
}
 
// Need this for each matpack type: Tensor4
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Tensor4& type) {
  dim_sizes.resize(0);
  if (type.nbooks() > min_num_elem) dim_sizes.push_back(type.nbooks());
  if (type.npages() > min_num_elem) dim_sizes.push_back(type.npages());
  if (type.nrows() > min_num_elem) dim_sizes.push_back(type.nrows());
  if (type.ncols() > min_num_elem) dim_sizes.push_back(type.ncols());
}
 
// Need this for each matpack type: Tensor5
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Tensor5& type) {
  dim_sizes.resize(0);
  if (type.nshelves() > min_num_elem) dim_sizes.push_back(type.nshelves());
  if (type.nbooks() > min_num_elem) dim_sizes.push_back(type.nbooks());
  if (type.npages() > min_num_elem) dim_sizes.push_back(type.npages());
  if (type.nrows() > min_num_elem) dim_sizes.push_back(type.nrows());
  if (type.ncols() > min_num_elem) dim_sizes.push_back(type.ncols());
}
 
// Need this for each matpack type: Tensor6
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Tensor6& type) {
  dim_sizes.resize(0);
  if (type.nvitrines() > min_num_elem) dim_sizes.push_back(type.nvitrines());
  if (type.nshelves() > min_num_elem) dim_sizes.push_back(type.nshelves());
  if (type.nbooks() > min_num_elem) dim_sizes.push_back(type.nbooks());
  if (type.npages() > min_num_elem) dim_sizes.push_back(type.npages());
  if (type.nrows() > min_num_elem) dim_sizes.push_back(type.nrows());
  if (type.ncols() > min_num_elem) dim_sizes.push_back(type.ncols());
}
 
// Need this for each matpack type: Tensor7
inline void select_dims_by_size(ArrayOfIndex& dim_sizes,
                         const Index min_num_elem,
                         const Tensor7& type) {
  dim_sizes.resize(0);
  if (type.nlibraries() > min_num_elem) dim_sizes.push_back(type.nlibraries());
  if (type.nvitrines() > min_num_elem) dim_sizes.push_back(type.nvitrines());
  if (type.nshelves() > min_num_elem) dim_sizes.push_back(type.nshelves());
  if (type.nbooks() > min_num_elem) dim_sizes.push_back(type.nbooks());
  if (type.npages() > min_num_elem) dim_sizes.push_back(type.npages());
  if (type.nrows() > min_num_elem) dim_sizes.push_back(type.nrows());
  if (type.ncols() > min_num_elem) dim_sizes.push_back(type.ncols());
}
 
 
// To Numeric
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Vector& i,
    const Verbosity&) {
  if (i.nelem() == 1)
    o = i[0];
  else {
    ostringstream os;
    os << "The Vector is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Matrix& i,
    const Verbosity&) {
  if (i.ncols() == 1 && i.nrows() == 1)
    o = i(0, 0);
  else {
    ostringstream os;
    os << "The Matrix is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Tensor3& i,
    const Verbosity&) {
  if (i.ncols() == 1 && i.nrows() == 1 && i.npages() == 1)
    o = i(0, 0, 0);
  else {
    ostringstream os;
    os << "The Tensor3 is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Tensor4& i,
    const Verbosity&) {
  if (i.ncols() == 1 && i.nrows() == 1 && i.npages() == 1 && i.nbooks() == 1)
    o = i(0, 0, 0, 0);
  else {
    ostringstream os;
    os << "The Tensor4 is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Tensor5& i,
    const Verbosity&) {
  if (i.ncols() == 1 && i.nrows() == 1 && i.npages() == 1 && i.nbooks() == 1 &&
      i.nshelves() == 1)
    o = i(0, 0, 0, 0, 0);
  else {
    ostringstream os;
    os << "The Tensor5 is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Tensor6& i,
    const Verbosity&) {
  if (i.ncols() == 1 && i.nrows() == 1 && i.npages() == 1 && i.nbooks() == 1 &&
      i.nshelves() == 1 && i.nvitrines() == 1)
    o = i(0, 0, 0, 0, 0, 0);
  else {
    ostringstream os;
    os << "The Tensor6 is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Numeric& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  if (i.ncols() == 1 && i.nrows() == 1 && i.npages() == 1 && i.nbooks() == 1 &&
      i.nshelves() == 1 && i.nvitrines() == 1 && i.nlibraries() == 1)
    o = i(0, 0, 0, 0, 0, 0, 0);
  else {
    ostringstream os;
    os << "The Tensor7 is not also a Numeric";
    throw std::runtime_error(os.str());
  }
}
 
//To Vector
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Vector& o,
    // WS Input:
    // WS Generic Input:
    const Matrix& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 1;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Matrix of size (" << dim_sizes << ") \n"
       << "does not fit a Vector";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Vector& o,
    // WS Input:
    // WS Generic Input:
    const Tensor3& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 1;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor3 of size (" << dim_sizes << ") \n"
       << "does not fit a Vector";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Vector& o,
    // WS Input:
    // WS Generic Input:
    const Tensor4& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 1;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor4 of size (" << dim_sizes << ") \n"
       << "does not fit a Vector";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Vector& o,
    // WS Input:
    // WS Generic Input:
    const Tensor5& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 1;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor5 of size (" << dim_sizes << ") \n"
       << "does not fit a Vector";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Vector& o,
    // WS Input:
    // WS Generic Input:
    const Tensor6& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 1;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor6 of size (" << dim_sizes << ") \n"
       << "does not fit a Vector";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Vector& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 1;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor7 of size (" << dim_sizes << ") \n"
       << "does not fit a Vector";
    throw std::runtime_error(os.str());
  }
}
 
// To Matrix
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Matrix& o,
    // WS Input:
    // WS Generic Input:
    const Tensor3& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 2;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor3 of size (" << dim_sizes << ") \n"
       << "does not fit a Matrix";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Matrix& o,
    // WS Input:
    // WS Generic Input:
    const Tensor4& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 2;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor4 of size (" << dim_sizes << ") \n"
       << "does not fit a Matrix";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Matrix& o,
    // WS Input:
    // WS Generic Input:
    const Tensor5& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 2;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor5 of size (" << dim_sizes << ") \n"
       << "does not fit a Matrix";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Matrix& o,
    // WS Input:
    // WS Generic Input:
    const Tensor6& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 2;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor6 of size (" << dim_sizes << ") \n"
       << "does not fit a Matrix";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Matrix& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 2;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor7 of size (" << dim_sizes << ") \n"
       << "does not fit a Matrix";
    throw std::runtime_error(os.str());
  }
}
 
// To Tensor 3
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor3& o,
    // WS Input:
    // WS Generic Input:
    const Tensor4& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 3;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor4 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor3";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor3& o,
    // WS Input:
    // WS Generic Input:
    const Tensor5& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 3;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor5 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor3";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor3& o,
    // WS Input:
    // WS Generic Input:
    const Tensor6& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 3;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor6 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor3";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor3& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 3;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor7 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor3";
    throw std::runtime_error(os.str());
  }
}
 
// To Tensor4
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor4& o,
    // WS Input:
    // WS Generic Input:
    const Tensor5& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 4;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2], dim_sizes[3]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor5 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor4";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor4& o,
    // WS Input:
    // WS Generic Input:
    const Tensor6& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 4;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2], dim_sizes[3]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor6 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor4";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor4& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 4;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0], dim_sizes[1], dim_sizes[2], dim_sizes[3]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor7 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor4";
    throw std::runtime_error(os.str());
  }
}
 
// To Tensor5
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor5& o,
    // WS Input:
    // WS Generic Input:
    const Tensor6& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 5;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(
        dim_sizes[0], dim_sizes[1], dim_sizes[2], dim_sizes[3], dim_sizes[4]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor6 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor5";
    throw std::runtime_error(os.str());
  }
}
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor5& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 5;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(
        dim_sizes[0], dim_sizes[1], dim_sizes[2], dim_sizes[3], dim_sizes[4]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor7 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor5";
    throw std::runtime_error(os.str());
  }
}
 
// To Tensor6
 
/* Workspace method: Doxygen documentation will be auto-generated */
inline void Reduce(
    // WS Generic Output:
    Tensor6& o,
    // WS Input:
    // WS Generic Input:
    const Tensor7& i,
    const Verbosity&) {
  ArrayOfIndex dim_sizes;
  Index test = 6;
 
  select_dims_by_size(dim_sizes, 1, i);
  Index num = dim_sizes.nelem();
  if (num == test) {
    o.resize(dim_sizes[0],
             dim_sizes[1],
             dim_sizes[2],
             dim_sizes[3],
             dim_sizes[4],
             dim_sizes[5]);
    memcpy(o.get_c_array(),
           i.get_c_array(),
           sizeof(Numeric) * num_elem_from_dim_sizes(dim_sizes));
  } else {
    ostringstream os;
    os << "The Tensor7 of size (" << dim_sizes << ") \n"
       << "does not fit a Tensor6";
    throw std::runtime_error(os.str());
  }
}
 
#endif /* m_reduce_h */