24 #if defined (HAVE_CONFIG_H)
41 if (old_dims.
ndims () == 2 && old_dims(0) == 1)
43 else if (old_dims.
ndims () == 2 && old_dims(0) == 0 && old_dims(1) == 0)
49 template <
typename ArrayType>
61 data =
reinterpret_cast<const void *
> (array.data ());
62 byte_size = array.byte_size ();
64 old_dims = array.dims ();
67 template <
typename ArrayType>
72 typedef typename ArrayType::element_type T;
75 if (n * static_cast<int> (
sizeof (T)) != byte_size)
76 error (
"typecast: incorrect number of input values to make output value");
79 T *dest = retval.fortran_vec ();
80 std::memcpy (dest, data, n *
sizeof (T));
140 if (
args.length () != 2)
147 const void *data = 0;
192 byte_size, old_dims,
frame);
195 byte_size, old_dims,
frame);
207 error (
"typecast: invalid input class: %s",
212 if (numclass.size () == 0)
214 else if (numclass ==
"char")
216 (data, byte_size, old_dims), array.
is_dq_string () ?
'"'
218 else if (numclass[0] ==
'i')
220 if (numclass ==
"int8")
221 retval = reinterpret_copy<int8NDArray> (data, byte_size, old_dims);
222 else if (numclass ==
"int16")
223 retval = reinterpret_copy<int16NDArray> (data, byte_size, old_dims);
224 else if (numclass ==
"int32")
225 retval = reinterpret_copy<int32NDArray> (data, byte_size, old_dims);
226 else if (numclass ==
"int64")
227 retval = reinterpret_copy<int64NDArray> (data, byte_size, old_dims);
229 else if (numclass[0] ==
'u')
231 if (numclass ==
"uint8")
232 retval = reinterpret_copy<uint8NDArray> (data, byte_size, old_dims);
233 else if (numclass ==
"uint16")
234 retval = reinterpret_copy<uint16NDArray> (data, byte_size,
236 else if (numclass ==
"uint32")
237 retval = reinterpret_copy<uint32NDArray> (data, byte_size,
239 else if (numclass ==
"uint64")
240 retval = reinterpret_copy<uint64NDArray> (data, byte_size,
243 else if (numclass ==
"single")
244 retval = reinterpret_copy<FloatNDArray> (data, byte_size, old_dims);
245 else if (numclass ==
"double")
246 retval = reinterpret_copy<NDArray> (data, byte_size, old_dims);
247 else if (numclass ==
"single complex")
248 retval = reinterpret_copy<FloatComplexNDArray> (data, byte_size,
250 else if (numclass ==
"double complex")
251 retval = reinterpret_copy<ComplexNDArray> (data, byte_size, old_dims);
254 error (
"typecast: cannot convert to %s class", numclass.c_str ());
287 template <
typename ArrayType>
291 typedef typename ArrayType::element_type T;
293 = bitp.
numel () / (
sizeof (T) * std::numeric_limits<unsigned char>::digits);
295 if (n * static_cast<int> (
sizeof (T)) *
296 std::numeric_limits<unsigned char>::digits != bitp.
numel ())
297 error (
"bitpack: incorrect number of bits to make up output value");
302 char *packed =
reinterpret_cast<char *
> (
retval.fortran_vec ());
309 for (
int j = 1; j < std::numeric_limits<unsigned char>::digits; j++)
313 bits += std::numeric_limits<unsigned char>::digits;
355 if (
args.length () != 2)
358 if (!
args(0).is_bool_type ())
359 error (
"bitpack: X must be a logical array");
367 if (numclass.size () == 0)
369 else if (numclass ==
"char")
370 retval =
octave_value (do_bitpack<charNDArray> (bitp),
'\'');
371 else if (numclass[0] ==
'i')
373 if (numclass ==
"int8")
374 retval = do_bitpack<int8NDArray> (bitp);
375 else if (numclass ==
"int16")
376 retval = do_bitpack<int16NDArray> (bitp);
377 else if (numclass ==
"int32")
378 retval = do_bitpack<int32NDArray> (bitp);
379 else if (numclass ==
"int64")
380 retval = do_bitpack<int64NDArray> (bitp);
382 else if (numclass[0] ==
'u')
384 if (numclass ==
"uint8")
385 retval = do_bitpack<uint8NDArray> (bitp);
386 else if (numclass ==
"uint16")
387 retval = do_bitpack<uint16NDArray> (bitp);
388 else if (numclass ==
"uint32")
389 retval = do_bitpack<uint32NDArray> (bitp);
390 else if (numclass ==
"uint64")
391 retval = do_bitpack<uint64NDArray> (bitp);
393 else if (numclass ==
"single")
394 retval = do_bitpack<FloatNDArray> (bitp);
395 else if (numclass ==
"double")
396 retval = do_bitpack<NDArray> (bitp);
397 else if (numclass ==
"single complex")
398 retval = do_bitpack<FloatComplexNDArray> (bitp);
399 else if (numclass ==
"double complex")
400 retval = do_bitpack<ComplexNDArray> (bitp);
403 error (
"bitpack: cannot pack to %s class", numclass.c_str ());
432 template <
typename ArrayType>
434 do_bitunpack (
const ArrayType&
array)
436 typedef typename ArrayType::element_type T;
438 * std::numeric_limits<unsigned char>::digits;
442 const char *packed =
reinterpret_cast<const char *
> (array.fortran_vec ());
443 bool *bits = retval.fortran_vec ();
451 for (
int j = 1; j < std::numeric_limits<unsigned char>::digits; j++)
452 bits[j] = (c >>= 1) & 1;
453 bits += std::numeric_limits<unsigned char>::digits;
488 if (
args.length () != 1)
491 if (! (
args(0).is_numeric_type () ||
args(0).is_string ()))
492 error (
"bitunpack: argument must be a number or a string");
536 error (
"bitunpack: invalid input class: %s",
uint8NDArray uint8_array_value(void) const
ComplexNDArray complex_array_value(bool frc_str_conv=false) const
charNDArray char_array_value(bool frc_str_conv=false) const
bool is_real_type(void) const
int8NDArray int8_array_value(void) const
bool is_uint16_type(void) const
OCTINTERP_API void print_usage(void)
octave_idx_type numel(void) const
Number of elements in the array.
int16NDArray int16_array_value(void) const
uint64NDArray uint64_array_value(void) const
#define DEFUN(name, args_name, nargout_name, doc)
void error(const char *fmt,...)
int32NDArray int32_array_value(void) const
bool is_int8_type(void) const
static void get_data_and_bytesize(const ArrayType &array, const void *&data, octave_idx_type &byte_size, dim_vector &old_dims, octave::unwind_protect &frame)
bool is_int32_type(void) const
typecast(ar{x},"uint8") esult
boolNDArray bool_array_value(bool warn=false) const
int64NDArray int64_array_value(void) const
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
FloatNDArray float_array_value(bool frc_str_conv=false) const
bool is_bool_type(void) const
nd deftypefn *octave_map m
then the function must return scalars which will be concatenated into the return array(s).If code
FloatComplexNDArray float_complex_array_value(bool frc_str_conv=false) const
bool is_string(void) const
bool is_complex_type(void) const
bool is_int64_type(void) const
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
bool is_int16_type(void) const
octave::unwind_protect frame
NDArray array_value(bool frc_str_conv=false) const
static ArrayType reinterpret_copy(const void *data, octave_idx_type byte_size, const dim_vector &old_dims)
bool is_dq_string(void) const
=val(i)}if ode{val(i)}occurs in table i
bool is_uint8_type(void) const
octave_idx_type ndims(void) const
Number of dimensions.
std::string class_name(void) const
static dim_vector get_vec_dims(const dim_vector &old_dims, octave_idx_type n)
bool is_undefined(void) const
bool is_uint64_type(void) const
const T * fortran_vec(void) const
bool is_single_type(void) const
bool is_uint32_type(void) const
Vector representing the dimensions (size) of an Array.
uint32NDArray uint32_array_value(void) const
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
uint16NDArray uint16_array_value(void) const
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
bool is_integer_type(void) const