/*

Copyright (C) 2004-2015 David Bateman
Copyright (C) 2009 VZLU Prague

This file is part of Octave.

Octave 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 3 of the License, or (at your
option) any later version.

Octave 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 Octave; see the file COPYING.  If not, see
<http://www.gnu.org/licenses/>.

*/

#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <algorithm>
#include "Array.h"
#include "Sparse.h"
#include "mx-base.h"

#include "ov.h"
#include "Cell.h"

#include "defun.h"
#include "error.h"
#include "ovl.h"

// The bulk of the work.
template <typename T>
static Array<T>
do_tril (const Array<T>& a, octave_idx_type k, bool pack)
{
  octave_idx_type nr = a.rows ();
  octave_idx_type nc = a.columns ();
  const T *avec = a.fortran_vec ();
  octave_idx_type zero = 0;

  if (pack)
    {
      octave_idx_type j1 = std::min (std::max (zero, k), nc);
      octave_idx_type j2 = std::min (std::max (zero, nr + k), nc);
      octave_idx_type n = j1 * nr + ((j2 - j1) * (nr-(j1-k) + nr-(j2-1-k))) / 2;
      Array<T> r (dim_vector (n, 1));
      T *rvec = r.fortran_vec ();
      for (octave_idx_type j = 0; j < nc; j++)
        {
          octave_idx_type ii = std::min (std::max (zero, j - k), nr);
          rvec = std::copy (avec + ii, avec + nr, rvec);
          avec += nr;
        }

      return r;
    }
  else
    {
      Array<T> r (a.dims ());
      T *rvec = r.fortran_vec ();
      for (octave_idx_type j = 0; j < nc; j++)
        {
          octave_idx_type ii = std::min (std::max (zero, j - k), nr);
          std::fill (rvec, rvec + ii, T ());
          std::copy (avec + ii, avec + nr, rvec + ii);
          avec += nr;
          rvec += nr;
        }

      return r;
    }
}

template <typename T>
static Array<T>
do_triu (const Array<T>& a, octave_idx_type k, bool pack)
{
  octave_idx_type nr = a.rows ();
  octave_idx_type nc = a.columns ();
  const T *avec = a.fortran_vec ();
  octave_idx_type zero = 0;

  if (pack)
    {
      octave_idx_type j1 = std::min (std::max (zero, k), nc);
      octave_idx_type j2 = std::min (std::max (zero, nr + k), nc);
      octave_idx_type n
        = ((j2 - j1) * ((j1+1-k) + (j2-k))) / 2 + (nc - j2) * nr;
      Array<T> r (dim_vector (n, 1));
      T *rvec = r.fortran_vec ();
      for (octave_idx_type j = 0; j < nc; j++)
        {
          octave_idx_type ii = std::min (std::max (zero, j + 1 - k), nr);
          rvec = std::copy (avec, avec + ii, rvec);
          avec += nr;
        }

      return r;
    }
  else
    {
      NoAlias<Array<T> > r (a.dims ());
      T *rvec = r.fortran_vec ();
      for (octave_idx_type j = 0; j < nc; j++)
        {
          octave_idx_type ii = std::min (std::max (zero, j + 1 - k), nr);
          std::copy (avec, avec + ii, rvec);
          std::fill (rvec + ii, rvec + nr, T ());
          avec += nr;
          rvec += nr;
        }

      return r;
    }
}

// These two are by David Bateman.
// FIXME: optimizations possible. "pack" support missing.

template <typename T>
static Sparse<T>
do_tril (const Sparse<T>& a, octave_idx_type k, bool pack)
{
  if (pack) // FIXME
    error ("tril: \"pack\" not implemented for sparse matrices");

  Sparse<T> m = a;
  octave_idx_type nc = m.cols ();

  for (octave_idx_type j = 0; j < nc; j++)
    for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++)
      if (m.ridx (i) < j-k)
        m.data(i) = 0.;

  m.maybe_compress (true);

  return m;
}

template <typename T>
static Sparse<T>
do_triu (const Sparse<T>& a, octave_idx_type k, bool pack)
{
  if (pack) // FIXME
    error ("triu: \"pack\" not implemented for sparse matrices");

  Sparse<T> m = a;
  octave_idx_type nc = m.cols ();

  for (octave_idx_type j = 0; j < nc; j++)
    for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++)
      if (m.ridx (i) > j-k)
        m.data(i) = 0.;

  m.maybe_compress (true);
  return m;
}

// Convenience dispatchers.
template <typename T>
static Array<T>
do_trilu (const Array<T>& a, octave_idx_type k, bool lower, bool pack)
{
  return lower ? do_tril (a, k, pack) : do_triu (a, k, pack);
}

template <typename T>
static Sparse<T>
do_trilu (const Sparse<T>& a, octave_idx_type k, bool lower, bool pack)
{
  return lower ? do_tril (a, k, pack) : do_triu (a, k, pack);
}

static octave_value
do_trilu (const std::string& name,
          const octave_value_list& args)
{
  bool lower = (name == "tril");

  int nargin = args.length ();
  bool pack = false;

  if (nargin >= 2 && args(nargin-1).is_string ())
    {
      pack = (args(nargin-1).string_value () == "pack");
      nargin--;
    }

  if (nargin < 1 || nargin > 2)
    print_usage ();

  octave_idx_type k = 0;
  if (nargin == 2)
    k = args(1).idx_type_value (true);

  octave_value arg = args(0);

  dim_vector dims = arg.dims ();
  if (dims.ndims () != 2)
    error ("%s: need a 2-D matrix", name.c_str ());
  else if (k < -dims(0) || k > dims(1))
    error ("%s: requested diagonal out of range", name.c_str ());

  octave_value retval;

  switch (arg.builtin_type ())
    {
    case btyp_double:
      if (arg.is_sparse_type ())
        retval = do_trilu (arg.sparse_matrix_value (), k, lower, pack);
      else
        retval = do_trilu (arg.array_value (), k, lower, pack);
      break;

    case btyp_complex:
      if (arg.is_sparse_type ())
        retval = do_trilu (arg.sparse_complex_matrix_value (), k, lower,
                           pack);
      else
        retval = do_trilu (arg.complex_array_value (), k, lower, pack);
      break;

    case btyp_bool:
      if (arg.is_sparse_type ())
        retval = do_trilu (arg.sparse_bool_matrix_value (), k, lower,
                           pack);
      else
        retval = do_trilu (arg.bool_array_value (), k, lower, pack);
      break;

#define ARRAYCASE(TYP)                                                  \
      case btyp_ ## TYP:                                                \
        retval = do_trilu (arg.TYP ## _array_value (), k, lower, pack); \
        break

      ARRAYCASE (float);
      ARRAYCASE (float_complex);
      ARRAYCASE (int8);
      ARRAYCASE (int16);
      ARRAYCASE (int32);
      ARRAYCASE (int64);
      ARRAYCASE (uint8);
      ARRAYCASE (uint16);
      ARRAYCASE (uint32);
      ARRAYCASE (uint64);
      ARRAYCASE (char);

#undef ARRAYCASE

    default:
      {
        // Generic code that works on octave-values, that is slow
        // but will also work on arbitrary user types
        if (pack) // FIXME
          error ("%s: \"pack\" not implemented for class %s",
                 name.c_str (), arg.class_name ().c_str ());

        octave_value tmp = arg;
        if (arg.is_empty ())
          return arg;

        octave_idx_type nr = dims(0);
        octave_idx_type nc = dims(1);

        // The sole purpose of this code is to force the correct matrix size.
        // This would not be necessary if the octave_value resize function
        // allowed a fill_value.  It also allows odd attributes in some user
        // types to be handled.  With a fill_value, it should be replaced with
        //
        // octave_value_list ov_idx;
        // tmp = tmp.resize(dim_vector (0,0)).resize (dims, fill_value);

        octave_value_list ov_idx;
        std::list<octave_value_list> idx_tmp;
        ov_idx(1) = static_cast<double> (nc+1);
        ov_idx(0) = Range (1, nr);
        idx_tmp.push_back (ov_idx);
        ov_idx(1) = static_cast<double> (nc);
        tmp = tmp.resize (dim_vector (0,0));
        tmp = tmp.subsasgn ("(",idx_tmp, arg.do_index_op (ov_idx));
        tmp = tmp.resize (dims);

        if (lower)
          {
            octave_idx_type st = nc < nr + k ? nc : nr + k;

            for (octave_idx_type j = 1; j <= st; j++)
              {
                octave_idx_type nr_limit = 1 > j - k ? 1 : j - k;
                ov_idx(1) = static_cast<double> (j);
                ov_idx(0) = Range (nr_limit, nr);
                std::list<octave_value_list> idx;
                idx.push_back (ov_idx);

                tmp = tmp.subsasgn ("(", idx, arg.do_index_op (ov_idx));
              }
          }
        else
          {
            octave_idx_type st = k + 1 > 1 ? k + 1 : 1;

            for (octave_idx_type j = st; j <= nc; j++)
              {
                octave_idx_type nr_limit = nr < j - k ? nr : j - k;
                ov_idx(1) = static_cast<double> (j);
                ov_idx(0) = Range (1, nr_limit);
                std::list<octave_value_list> idx;
                idx.push_back (ov_idx);

                tmp = tmp.subsasgn ("(", idx, arg.do_index_op (ov_idx));
              }
          }

        retval = tmp;
      }
    }

  return retval;
}

DEFUN (tril, args, ,
       doc: /* -*- texinfo -*-
@deftypefn  {} {} tril (@var{A})
@deftypefnx {} {} tril (@var{A}, @var{k})
@deftypefnx {} {} tril (@var{A}, @var{k}, @var{pack})
@deftypefnx {} {} triu (@var{A})
@deftypefnx {} {} triu (@var{A}, @var{k})
@deftypefnx {} {} triu (@var{A}, @var{k}, @var{pack})
Return a new matrix formed by extracting the lower (@code{tril})
or upper (@code{triu}) triangular part of the matrix @var{A}, and
setting all other elements to zero.

The second argument is optional, and specifies how many diagonals above or
below the main diagonal should also be set to zero.

The default value of @var{k} is zero, so that @code{triu} and @code{tril}
normally include the main diagonal as part of the result.

If the value of @var{k} is nonzero integer, the selection of elements starts
at an offset of @var{k} diagonals above or below the main diagonal; above
for positive @var{k} and below for negative @var{k}.

The absolute value of @var{k} must not be greater than the number of
subdiagonals or superdiagonals.

For example:

@example
@group
tril (ones (3), -1)
     @result{}  0  0  0
         1  0  0
         1  1  0
@end group
@end example

@noindent
and

@example
@group
tril (ones (3), 1)
     @result{}  1  1  0
         1  1  1
         1  1  1
@end group
@end example

If the option @qcode{"pack"} is given as third argument, the extracted
elements are not inserted into a matrix, but rather stacked column-wise one
above other.
@seealso{diag}
@end deftypefn */)
{
  return do_trilu ("tril", args);
}

DEFUN (triu, args, ,
       doc: /* -*- texinfo -*-
@deftypefn  {} {} triu (@var{A})
@deftypefnx {} {} triu (@var{A}, @var{k})
@deftypefnx {} {} triu (@var{A}, @var{k}, @var{pack})
See the documentation for the @code{tril} function (@pxref{tril}).
@seealso{tril}
@end deftypefn */)
{
  return do_trilu ("triu", args);
}

/*
%!test
%! a = [1, 2, 3; 4, 5, 6; 7, 8, 9; 10, 11, 12];
%!
%! l0 = [1, 0, 0; 4, 5, 0; 7, 8, 9; 10, 11, 12];
%! l1 = [1, 2, 0; 4, 5, 6; 7, 8, 9; 10, 11, 12];
%! l2 = [1, 2, 3; 4, 5, 6; 7, 8, 9; 10, 11, 12];
%! lm1 = [0, 0, 0; 4, 0, 0; 7, 8, 0; 10, 11, 12];
%! lm2 = [0, 0, 0; 0, 0, 0; 7, 0, 0; 10, 11, 0];
%! lm3 = [0, 0, 0; 0, 0, 0; 0, 0, 0; 10, 0, 0];
%! lm4 = [0, 0, 0; 0, 0, 0; 0, 0, 0; 0, 0, 0];
%!
%! assert (tril (a, -4), lm4);
%! assert (tril (a, -3), lm3);
%! assert (tril (a, -2), lm2);
%! assert (tril (a, -1), lm1);
%! assert (tril (a), l0);
%! assert (tril (a, 1), l1);
%! assert (tril (a, 2), l2);

%!error tril ()
*/