structs.hpp

Go to the documentation of this file.

#ifndef VIENNACL_LINALG_DETAIL_BISECT_STRUCTS_HPP_
#define VIENNACL_LINALG_DETAIL_BISECT_STRUCTS_HPP_

/* =========================================================================
   Copyright (c) 2010-2015, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
   Portions of this software are copyright by UChicago Argonne, LLC.

                            -----------------
                  ViennaCL - The Vienna Computing Library
                            -----------------

   Project Head:    Karl Rupp                   rupp@iue.tuwien.ac.at

   (A list of authors and contributors can be found in the manual)

   License:         MIT (X11), see file LICENSE in the base directory
============================================================================= */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <assert.h>

#include "viennacl/vector.hpp"
#include "viennacl/matrix.hpp"

namespace viennacl
{
namespace linalg
{
namespace detail
{

template<typename NumericT>
struct InputData
{
  std::vector<NumericT> std_a;
  std::vector<NumericT> std_b;
  viennacl::vector<NumericT> g_a;
  viennacl::vector<NumericT> g_b;

  InputData(std::vector<NumericT> diagonal, std::vector<NumericT> superdiagonal, const unsigned int sz) :
              std_a(sz), std_b(sz), g_a(sz), g_b(sz)
  {
   std_a = diagonal;
   std_b = superdiagonal;

   viennacl::copy(std_b, g_b);
   viennacl::copy(std_a, g_a);
  }

  InputData(viennacl::vector<NumericT> diagonal, viennacl::vector<NumericT> superdiagonal, const unsigned int sz) :
              std_a(sz), std_b(sz), g_a(sz), g_b(sz)
  {
   g_a = diagonal;
   g_b = superdiagonal;

   viennacl::copy(g_a, std_a);
   viennacl::copy(g_b, std_b);
  }
};


template<typename NumericT>
struct ResultDataSmall
{
  std::vector<NumericT> std_eigenvalues;
  viennacl::vector<NumericT> vcl_g_left;
  viennacl::vector<NumericT> vcl_g_right;
  viennacl::vector<unsigned int> vcl_g_left_count;
  viennacl::vector<unsigned int> vcl_g_right_count;


  ResultDataSmall(const unsigned int mat_size) :
    std_eigenvalues(mat_size), vcl_g_left(mat_size), vcl_g_right(mat_size), vcl_g_left_count(mat_size), vcl_g_right_count(mat_size) {}
};





template<typename NumericT>
struct ResultDataLarge
{
  std::vector<NumericT> std_eigenvalues;

  viennacl::scalar<unsigned int> g_num_one;

  viennacl::scalar<unsigned int> g_num_blocks_mult;

  viennacl::vector<NumericT> g_left_one;

  viennacl::vector<NumericT> g_right_one;

  viennacl::vector<unsigned int> g_pos_one;

  viennacl::vector<NumericT> g_left_mult;
  viennacl::vector<NumericT> g_right_mult;

  viennacl::vector<unsigned int> g_left_count_mult;

  viennacl::vector<unsigned int> g_right_count_mult;
  viennacl::vector<unsigned int> g_blocks_mult;

  viennacl::vector<unsigned int> g_blocks_mult_sum;

  viennacl::vector<NumericT> g_lambda_mult;

  viennacl::vector<unsigned int> g_pos_mult;

  ResultDataLarge(unsigned int mat_size) :
    std_eigenvalues(mat_size), g_num_one(0), g_num_blocks_mult(0),
    g_left_one(mat_size), g_right_one(mat_size), g_pos_one(mat_size),
    g_left_mult(mat_size), g_right_mult(mat_size), g_left_count_mult(mat_size), g_right_count_mult(mat_size),
    g_blocks_mult(mat_size), g_blocks_mult_sum(mat_size), g_lambda_mult(mat_size), g_pos_mult(mat_size) {}

};
} // namespace detail
} // namespace linalg
} // namespace viennacl
#endif // #ifndef VIENNACL_LINALG_DETAIL_STRUCTS_HPP_