/*

Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2006,

              2007 John W. Eaton

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/>.

*/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <iostream>

#include "lo-ieee.h"

#include "lo-utils.h"

#include "gripes.h"

#include "ops.h"

#include "oct-obj.h"

#include "ov-range.h"

#include "ov-re-mat.h"

#include "ov-scalar.h"

#include "pr-output.h"

#include "byte-swap.h"

#include "ls-hdf5.h"

#include "ls-utils.h"

#include "ls-ascii-helper.h"

DEFINE_OCTAVE_ALLOCATOR (octave_range);

DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_range, "range", "double");

static octave_base_value *

default_numeric_conversion_function (const octave_base_value& a)

{

  CAST_CONV_ARG (const octave_range&);

  return new octave_matrix (v.matrix_value ());

}

octave_base_value::type_conv_fcn

octave_range::numeric_conversion_function (void) const

{

  return default_numeric_conversion_function;

}

octave_base_value *

octave_range::try_narrowing_conversion (void)

{

  octave_base_value *retval = 0;

  switch (range.nelem ())

    {

    case 1:

      retval = new octave_scalar (range.base ());

      break;

    case 0:

      retval = new octave_matrix (Matrix (1, 0));

      break;

    default:

      break;

    }

  return retval;

}

octave_value

octave_range::subsref (const std::string& type,

		       const std::list<octave_value_list>& idx)

{

  octave_value retval;

  switch (type[0])

    {

    case '(':

      retval = do_index_op (idx.front ());

      break;

    case '{':

    case '.':

      {

	std::string nm = type_name ();

	error ("%s cannot be indexed with %c", nm.c_str (), type[0]);

      }

      break;

    default:

      panic_impossible ();

    }

  return retval.next_subsref (type, idx);

}

octave_value

octave_range::do_index_op (const octave_value_list& idx, bool resize_ok)

{

  // FIXME -- this doesn't solve the problem of

  //

  //   a = 1:5; a(1, 1, 1)

  //

  // and similar constructions.  Hmm...

  // FIXME -- using this constructor avoids possibly narrowing

  // the range to a scalar value.  Need a better solution to this

  // problem.

  octave_value tmp (new octave_matrix (range.matrix_value ()));

  return tmp.do_index_op (idx, resize_ok);

}

double

octave_range::double_value (bool) const

{

  double retval = lo_ieee_nan_value ();

  octave_idx_type nel = range.nelem ();

  if (nel > 0)

    {

      gripe_implicit_conversion ("Octave:array-as-scalar",

				 "range", "real scalar");

      retval = range.base ();

    }

  else

    gripe_invalid_conversion ("range", "real scalar");

  return retval;

}

octave_value

octave_range::all (int dim) const

{

  // FIXME -- this is a potential waste of memory.

  Matrix m = range.matrix_value ();

  return m.all (dim);

}

octave_value

octave_range::any (int dim) const

{

  // FIXME -- this is a potential waste of memory.

  Matrix m = range.matrix_value ();

  return m.any (dim);

}

bool

octave_range::is_true (void) const

{

  bool retval = false;

  if (range.nelem () != 0)

    {

      // FIXME -- this is a potential waste of memory.

      Matrix m ((range.matrix_value () . all ()) . all ());

      retval = (m.rows () == 1 && m.columns () == 1 && m (0, 0) != 0.0);

    }

  return retval;

}

Complex

octave_range::complex_value (bool) const

{

  double tmp = lo_ieee_nan_value ();

  Complex retval (tmp, tmp);

  octave_idx_type nel = range.nelem ();

  if (nel > 0)

    {

      gripe_implicit_conversion ("Octave:array-as-scalar",

				 "range", "complex scalar");

      retval = range.base ();

    }

  else

    gripe_invalid_conversion ("range", "complex scalar");

  return retval;

}

octave_value 

octave_range::resize (const dim_vector& dv, bool fill) const

{ 

  NDArray retval = array_value (); 

  if (fill)

    retval.resize (dv, NDArray::resize_fill_value());

  else

    retval.resize (dv); 

  return retval; 

}

octave_value

octave_range::convert_to_str_internal (bool pad, bool force, char type) const

{

  octave_value tmp (range.matrix_value ());

  return tmp.convert_to_str (pad, force, type);

}

void

octave_range::print (std::ostream& os, bool pr_as_read_syntax) const

{

  print_raw (os, pr_as_read_syntax);

  newline (os);

}

void

octave_range::print_raw (std::ostream& os, bool pr_as_read_syntax) const

{

  octave_print_internal (os, range, pr_as_read_syntax,

			 current_print_indent_level ());

}

bool

octave_range::print_name_tag (std::ostream& os, const std::string& name) const

{

  bool retval = false;

  octave_idx_type n = range.nelem ();

  indent (os);

  if (n == 0 || n == 1)

    os << name << " = ";

  else

    {

      os << name << " =";

      newline (os);

      newline (os);

      retval = true;

    }

  return retval;

}

// Skip white space and comments on stream IS.

static void

skip_comments (std::istream& is)

{

  char c = '\0';

  while (is.get (c))

    {

      if (c == ' ' || c == '\t' || c == '\n')

	; // Skip whitespace on way to beginning of next line.

      else

	break;

    }

  // Skip to beginning of next line, ignoring everything.

  skip_until_newline (is, false);

}

bool 

octave_range::save_ascii (std::ostream& os)

{

  Range r = range_value ();

  double base = r.base ();

  double limit = r.limit ();

  double inc = r.inc ();

  os << "# base, limit, increment\n";

  octave_write_double (os, base);

  os << " ";

  octave_write_double (os, limit);

  os << " ";

  octave_write_double (os, inc);

  os << "\n";

  return true;

}

bool 

octave_range::load_ascii (std::istream& is)

{

  // # base, limit, range comment added by save ().

  skip_comments (is);

  is >> range;

  if (!is)

    {

      error ("load: failed to load range constant");

      return false;

    }

  return true;

}

bool 

octave_range::save_binary (std::ostream& os, bool& /* save_as_floats */)

{

  char tmp = LS_DOUBLE;

  os.write (reinterpret_cast<char *> (&tmp), 1);

  Range r = range_value ();

  double bas = r.base ();

  double lim = r.limit ();

  double inc = r.inc ();

  os.write (reinterpret_cast<char *> (&bas), 8);

  os.write (reinterpret_cast<char *> (&lim), 8);

  os.write (reinterpret_cast<char *> (&inc), 8);

  return true;

}

bool 

octave_range::load_binary (std::istream& is, bool swap,

			   oct_mach_info::float_format /* fmt */)

{

  char tmp;

  if (! is.read (reinterpret_cast<char *> (&tmp), 1))

    return false;

  double bas, lim, inc;

  if (! is.read (reinterpret_cast<char *> (&bas), 8))

    return false;

  if (swap)

    swap_bytes<8> (&bas);

  if (! is.read (reinterpret_cast<char *> (&lim), 8))

    return false;

  if (swap)

    swap_bytes<8> (&lim);

  if (! is.read (reinterpret_cast<char *> (&inc), 8))

    return false;

  if (swap)

    swap_bytes<8> (&inc);

  Range r (bas, lim, inc);

  range = r;

  return true;

}

#if defined (HAVE_HDF5)

// The following subroutines creates an HDF5 representation of the way

// we will store Octave range types (triplets of floating-point numbers). 

// NUM_TYPE is the HDF5 numeric type to use for storage (e.g. 

// H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary 

// conversions are handled automatically by HDF5.

static hid_t

hdf5_make_range_type (hid_t num_type)

{

  hid_t type_id = H5Tcreate (H5T_COMPOUND, sizeof (double) * 3);

  H5Tinsert (type_id, "base", 0 * sizeof (double), num_type);

  H5Tinsert (type_id, "limit", 1 * sizeof (double), num_type);

  H5Tinsert (type_id, "increment", 2 * sizeof (double), num_type);

  return type_id;

}

bool

octave_range::save_hdf5 (hid_t loc_id, const char *name,

			 bool /* save_as_floats */)

{

  hsize_t dimens[3];

  hid_t space_hid = -1, type_hid = -1, data_hid = -1;

  bool retval = true;

  space_hid = H5Screate_simple (0, dimens, 0);

  if (space_hid < 0) return false;

  type_hid = hdf5_make_range_type (H5T_NATIVE_DOUBLE);

  if (type_hid < 0) 

    {

      H5Sclose (space_hid);

      return false;

    }

  data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT);

  if (data_hid < 0) 

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      return false;

    }

  Range r = range_value ();

  double range_vals[3];

  range_vals[0] = r.base ();

  range_vals[1] = r.limit ();

  range_vals[2] = r.inc ();

  retval = H5Dwrite (data_hid, type_hid, H5S_ALL, H5S_ALL, H5P_DEFAULT,

		     range_vals) >= 0;

  H5Dclose (data_hid);

  H5Tclose (type_hid);

  H5Sclose (space_hid);

  return retval;

}

bool 

octave_range::load_hdf5 (hid_t loc_id, const char *name,

			 bool /* have_h5giterate_bug */)

{

  bool retval = false;

  hid_t data_hid = H5Dopen (loc_id, name);

  hid_t type_hid = H5Dget_type (data_hid);

  hid_t range_type = hdf5_make_range_type (H5T_NATIVE_DOUBLE);

  if (! hdf5_types_compatible (type_hid, range_type))

    {

      H5Tclose (range_type);

      H5Dclose (data_hid);

      return false;

    }

  hid_t space_hid = H5Dget_space (data_hid);

  hsize_t rank = H5Sget_simple_extent_ndims (space_hid);

  if (rank != 0)

    {

      H5Tclose (range_type);

      H5Sclose (space_hid);

      H5Dclose (data_hid);

      return false;

    }

  double rangevals[3];

  if (H5Dread (data_hid, range_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, 

	       rangevals) >= 0)

    {

      retval = true;

      Range r (rangevals[0], rangevals[1], rangevals[2]);

      range = r;

    }

  H5Tclose (range_type);

  H5Sclose (space_hid);

  H5Dclose (data_hid);

  return retval;

}

#endif

mxArray *

octave_range::as_mxArray (void) const

{

  mxArray *retval = new mxArray (mxDOUBLE_CLASS, dims (), mxREAL);

  double *pr = static_cast<double *> (retval->get_data ());

  mwSize nel = numel ();

  Matrix m = matrix_value ();

  const double *p = m.data ();

  for (mwSize i = 0; i < nel; i++)

    pr[i] = p[i];

  return retval;

}

/*

;;; Local Variables: ***

;;; mode: C++ ***

;;; End: ***

*/