octave-lyh: src/data.cc comparison

comparison src/data.cc @ 10716:f7f26094021b

improve cat code design in data.cc, make horzcat/vertcat more Matlab compatible

author	Jaroslav Hajek <highegg@gmail.com>
date	Mon, 21 Jun 2010 15:48:56 +0200
parents	fbd7843974fa
children	f3892d8eea9f

comparison

equal deleted inserted replaced

-:53253f796351
+:f7f26094021b
 single_type_concat (Array<T>& result,
 const octave_value_list& args,
 int dim)
 {
 int n_args = args.length ();
-OCTAVE_LOCAL_BUFFER (Array<T>, array_list, n_args - 1);
+OCTAVE_LOCAL_BUFFER (Array<T>, array_list, n_args);
-for (int j = 1; j < n_args && ! error_state; j++)
+for (int j = 0; j < n_args && ! error_state; j++)
 {
 octave_quit ();
-array_list[j-1] = octave_value_extract<TYPE> (args(j));
+array_list[j] = octave_value_extract<TYPE> (args(j));
 }
 if (! error_state)
-result = Array<T>::cat (dim, n_args-1, array_list);
+result = Array<T>::cat (dim, n_args, array_list);
 }
 template <class TYPE, class T>
 static void
 single_type_concat (Sparse<T>& result,
 const octave_value_list& args,
 int dim)
 {
 int n_args = args.length ();
-OCTAVE_LOCAL_BUFFER (Sparse<T>, sparse_list, n_args-1);
+OCTAVE_LOCAL_BUFFER (Sparse<T>, sparse_list, n_args);
-for (int j = 1; j < n_args && ! error_state; j++)
+for (int j = 0; j < n_args && ! error_state; j++)
 {
 octave_quit ();
-sparse_list[j-1] = octave_value_extract<TYPE> (args(j));
+sparse_list[j] = octave_value_extract<TYPE> (args(j));
 }
 if (! error_state)
-result = Sparse<T>::cat (dim, n_args-1, sparse_list);
+result = Sparse<T>::cat (dim, n_args, sparse_list);
 }
 // Dispatcher.
 template<class TYPE>
 static TYPE
 return result;
 }
 static octave_value
-do_cat (const octave_value_list& args, std::string fname)
+do_cat (const octave_value_list& args, int dim, std::string fname)
 {
 octave_value retval;
 int n_args = args.length ();
-if (n_args == 1)
+if (n_args == 0)
 retval = Matrix ();
-else if (n_args == 2)
+else if (n_args == 1)
-retval = args(1);
+retval = args(0);
-else if (n_args > 2)
+else if (n_args > 1)
 {
-octave_idx_type dim = args(0).int_value () - 1;
+std::string result_type = args(0).class_name ();
-if (error_state)
-{
+bool all_sq_strings_p = args(0).is_sq_string ();
-error ("cat: expecting first argument to be a integer");
+bool all_dq_strings_p = args(0).is_dq_string ();
-return retval;
+bool all_real_p = args(0).is_real_type ();
-}
+bool any_sparse_p = args(0).is_sparse_type();
-if (dim >= 0)
+for (int i = 1; i < args.length (); i++)
 {
+result_type =
-std::string result_type = args(1).class_name ();
+get_concat_class (result_type, args(i).class_name ());
-bool all_sq_strings_p = args(1).is_sq_string ();
+if (all_sq_strings_p && ! args(i).is_sq_string ())
-bool all_dq_strings_p = args(1).is_dq_string ();
+all_sq_strings_p = false;
-bool all_real_p = args(1).is_real_type ();
+if (all_dq_strings_p && ! args(i).is_dq_string ())
-bool any_sparse_p = args(1).is_sparse_type();
+all_dq_strings_p = false;
+if (all_real_p && ! args(i).is_real_type ())
-for (int i = 2; i < args.length (); i++)
+all_real_p = false;
+if (!any_sparse_p && args(i).is_sparse_type ())
+any_sparse_p = true;
+}
+if (result_type == "double")
+{
+if (any_sparse_p)
+{
+if (all_real_p)
+retval = do_single_type_concat<SparseMatrix> (args, dim);
+else
+retval = do_single_type_concat<SparseComplexMatrix> (args, dim);
+}
+else
 {
-result_type =
+if (all_real_p)
-get_concat_class (result_type, args(i).class_name ());
+retval = do_single_type_concat<NDArray> (args, dim);
+else
-if (all_sq_strings_p && ! args(i).is_sq_string ())
+retval = do_single_type_concat<ComplexNDArray> (args, dim);
-all_sq_strings_p = false;
-if (all_dq_strings_p && ! args(i).is_dq_string ())
-all_dq_strings_p = false;
-if (all_real_p && ! args(i).is_real_type ())
-all_real_p = false;
-if (!any_sparse_p && args(i).is_sparse_type ())
-any_sparse_p = true;
 }
+}
-if (result_type == "double")
+else if (result_type == "single")
+{
+if (all_real_p)
+retval = do_single_type_concat<FloatNDArray> (args, dim);
+else
+retval = do_single_type_concat<FloatComplexNDArray> (args, dim);
+}
+else if (result_type == "char")
+{
+char type = all_dq_strings_p ? '"' : '\'';
+maybe_warn_string_concat (all_dq_strings_p, all_sq_strings_p);
+charNDArray result =  do_single_type_concat<charNDArray> (args, dim);
+retval = octave_value (result, type);
+}
+else if (result_type == "logical")
+{
+if (any_sparse_p)
+retval = do_single_type_concat<SparseBoolMatrix> (args, dim);
+else
+retval = do_single_type_concat<boolNDArray> (args, dim);
+}
+else if (result_type == "int8")
+retval = do_single_type_concat<int8NDArray> (args, dim);
+else if (result_type == "int16")
+retval = do_single_type_concat<int16NDArray> (args, dim);
+else if (result_type == "int32")
+retval = do_single_type_concat<int32NDArray> (args, dim);
+else if (result_type == "int64")
+retval = do_single_type_concat<int64NDArray> (args, dim);
+else if (result_type == "uint8")
+retval = do_single_type_concat<uint8NDArray> (args, dim);
+else if (result_type == "uint16")
+retval = do_single_type_concat<uint16NDArray> (args, dim);
+else if (result_type == "uint32")
+retval = do_single_type_concat<uint32NDArray> (args, dim);
+else if (result_type == "uint64")
+retval = do_single_type_concat<uint64NDArray> (args, dim);
+else
+{
+dim_vector  dv = args(0).dims ();
+// Default concatenation.
+bool (dim_vector::*concat_rule) (const dim_vector&, int) = &dim_vector::concat;
+if (dim == -1 || dim == -2)
 {
-if (any_sparse_p)
+concat_rule = &dim_vector::hvcat;
-{
+dim = -dim - 1;
-if (all_real_p)
+}
-retval = do_single_type_concat<SparseMatrix> (args, dim);
-else
+for (int i = 1; i < args.length (); i++)
-retval = do_single_type_concat<SparseComplexMatrix> (args, dim);
+{
+if (! (dv.*concat_rule) (args(i).dims (), dim))
+{
+// Dimensions do not match.
+error ("cat: dimension mismatch");
+return retval;
+}
+}
+// The lines below might seem crazy, since we take a copy
+// of the first argument, resize it to be empty and then resize
+// it to be full. This is done since it means that there is no
+// recopying of data, as would happen if we used a single resize.
+// It should be noted that resize operation is also significantly
+// slower than the do_cat_op function, so it makes sense to have
+// an empty matrix and copy all data.
+//
+// We might also start with a empty octave_value using
+//   tmp = octave_value_typeinfo::lookup_type
+//                                (args(1).type_name());
+// and then directly resize. However, for some types there might
+// be some additional setup needed, and so this should be avoided.
+octave_value tmp = args (0);
+tmp = tmp.resize (dim_vector (0,0)).resize (dv);
+if (error_state)
+return retval;
+int dv_len = dv.length ();
+Array<octave_idx_type> ra_idx (dv_len, 1, 0);
+for (int j = 0; j < n_args; j++)
+{
+// Can't fast return here to skip empty matrices as something
+// like cat(1,[],single([])) must return an empty matrix of
+// the right type.
+tmp = do_cat_op (tmp, args (j), ra_idx);
+if (error_state)
+return retval;
+dim_vector dv_tmp = args (j).dims ();
+if (dim >= dv_len)
+{
+if (j > 1)
+error ("%s: indexing error", fname.c_str ());
+break;
 }
 else
-{
+ra_idx (dim) += (dim < dv_tmp.length () ?
-if (all_real_p)
+dv_tmp (dim) : 1);
-retval = do_single_type_concat<NDArray> (args, dim);
-else
-retval = do_single_type_concat<ComplexNDArray> (args, dim);
-}
 }
-else if (result_type == "single")
+retval = tmp;
-{
+}
-if (all_real_p)
-retval = do_single_type_concat<FloatNDArray> (args, dim);
-else
-retval = do_single_type_concat<FloatComplexNDArray> (args, dim);
-}
-else if (result_type == "char")
-{
-char type = all_dq_strings_p ? '"' : '\'';
-maybe_warn_string_concat (all_dq_strings_p, all_sq_strings_p);
-charNDArray result =  do_single_type_concat<charNDArray> (args, dim);
-retval = octave_value (result, type);
-}
-else if (result_type == "logical")
-{
-if (any_sparse_p)
-retval = do_single_type_concat<SparseBoolMatrix> (args, dim);
-else
-retval = do_single_type_concat<boolNDArray> (args, dim);
-}
-else if (result_type == "int8")
-retval = do_single_type_concat<int8NDArray> (args, dim);
-else if (result_type == "int16")
-retval = do_single_type_concat<int16NDArray> (args, dim);
-else if (result_type == "int32")
-retval = do_single_type_concat<int32NDArray> (args, dim);
-else if (result_type == "int64")
-retval = do_single_type_concat<int64NDArray> (args, dim);
-else if (result_type == "uint8")
-retval = do_single_type_concat<uint8NDArray> (args, dim);
-else if (result_type == "uint16")
-retval = do_single_type_concat<uint16NDArray> (args, dim);
-else if (result_type == "uint32")
-retval = do_single_type_concat<uint32NDArray> (args, dim);
-else if (result_type == "uint64")
-retval = do_single_type_concat<uint64NDArray> (args, dim);
-else
-{
-dim_vector  dv = args(1).dims ();
-for (int i = 2; i < args.length (); i++)
-{
-if (! dv.concat (args(i).dims (), dim))
-{
-// Dimensions do not match.
-error ("cat: dimension mismatch");
-return retval;
-}
-}
-// The lines below might seem crazy, since we take a copy
-// of the first argument, resize it to be empty and then resize
-// it to be full. This is done since it means that there is no
-// recopying of data, as would happen if we used a single resize.
-// It should be noted that resize operation is also significantly
-// slower than the do_cat_op function, so it makes sense to have
-// an empty matrix and copy all data.
-//
-// We might also start with a empty octave_value using
-//   tmp = octave_value_typeinfo::lookup_type
-//                                (args(1).type_name());
-// and then directly resize. However, for some types there might
-// be some additional setup needed, and so this should be avoided.
-octave_value tmp = args (1);
-tmp = tmp.resize (dim_vector (0,0)).resize (dv);
-if (error_state)
-return retval;
-int dv_len = dv.length ();
-Array<octave_idx_type> ra_idx (dv_len, 1, 0);
-for (int j = 1; j < n_args; j++)
-{
-// Can't fast return here to skip empty matrices as something
-// like cat(1,[],single([])) must return an empty matrix of
-// the right type.
-tmp = do_cat_op (tmp, args (j), ra_idx);
-if (error_state)
-return retval;
-dim_vector dv_tmp = args (j).dims ();
-if (dim >= dv_len)
-{
-if (j > 1)
-error ("%s: indexing error", fname.c_str ());
-break;
-}
-else
-ra_idx (dim) += (dim < dv_tmp.length () ?
-dv_tmp (dim) : 1);
-}
-retval = tmp;
-}
-}
-else
-error ("%s: invalid dimension argument", fname.c_str ());
 }
 else
 print_usage ();
 return retval;
 Return the horizontal concatenation of N-d array objects, @var{array1},\n\
 @var{array2}, @dots{}, @var{arrayN} along dimension 2.\n\
 @seealso{cat, vertcat}\n\
 @end deftypefn")
 {
-octave_value_list args_tmp = args;
+return do_cat (args, -2, "horzcat");
-int dim = 2;
-octave_value d (dim);
-args_tmp.prepend (d);
-return do_cat (args_tmp, "horzcat");
 }
 DEFUN (vertcat, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} vertcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\
 Return the vertical concatenation of N-d array objects, @var{array1},\n\
 @var{array2}, @dots{}, @var{arrayN} along dimension 1.\n\
 @seealso{cat, horzcat}\n\
 @end deftypefn")
 {
-octave_value_list args_tmp = args;
+return do_cat (args, -1, "vertcat");
-int dim = 1;
-octave_value d (dim);
-args_tmp.prepend (d);
-return do_cat (args_tmp, "vertcat");
 }
 DEFUN (cat, args, ,
 "-*- texinfo -*-\n\
 @deftypefn {Built-in Function} {} cat (@var{dim}, @var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\
 @end group\n\
 @end example\n\
 @seealso{horzcat, vertcat}\n\
 @end deftypefn")
 {
-return do_cat (args, "cat");
+octave_value retval;
+if (args.length () > 0)
+{
+int dim = args(0).int_value () - 1;
+if (! error_state)
+{
+if (dim >= 0)
+retval = do_cat (args.slice (1, args.length () - 1), dim, "cat");
+else
+error ("cat: invalid dimension specified");
+}
+else
+error ("cat: expecting first argument to be a integer");
+}
+else
+print_usage ();
+return retval;
 }
 /*
 %!function ret = testcat (t1, t2, tr, cmplx)

Mercurial > hg > octave-lyh

comparison src/data.cc @ 10716:f7f26094021b