Mercurial > octave

comparison libinterp/octave-value/ov-intx.h @ 31138:b3ca7f891750

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: use "m_" prefix for member variables in class octave_base_matrix. * ov-base-int.cc, ov-base-mat.cc, ov-base-mat.h, ov-base.h, ov-bool-mat.cc, ov-bool-mat.h, ov-cell.cc, ov-cell.h, ov-ch-mat.cc, ov-ch-mat.h, ov-cx-mat.cc, ov-cx-mat.h, ov-flt-cx-mat.cc, ov-flt-cx-mat.h, ov-flt-re-mat.cc, ov-flt-re-mat.h, ov-intx.h, ov-re-mat.cc, ov-re-mat.h, ov-str-mat.cc, ov-str-mat.h: use "m_" prefix for member variables in class octave_base_matrix.
author Rik <rik@octave.org>
date Sun, 10 Jul 2022 18:26:24 -0700
parents cbfe8318566a
children aac27ad79be6
comparison
equal deleted inserted replaced
31137:6308ce73bdca 31138:b3ca7f891750
81 builtin_type_t builtin_type (void) const { return OCTAVE_INT_BTYP; } 81 builtin_type_t builtin_type (void) const { return OCTAVE_INT_BTYP; }
82 82
83 public: 83 public:
84 84
85 int8NDArray 85 int8NDArray
86 int8_array_value (void) const { return int8NDArray (matrix); } 86 int8_array_value (void) const { return int8NDArray (m_matrix); }
87 87
88 int16NDArray 88 int16NDArray
89 int16_array_value (void) const { return int16NDArray (matrix); } 89 int16_array_value (void) const { return int16NDArray (m_matrix); }
90 90
91 int32NDArray 91 int32NDArray
92 int32_array_value (void) const { return int32NDArray (matrix); } 92 int32_array_value (void) const { return int32NDArray (m_matrix); }
93 93
94 int64NDArray 94 int64NDArray
95 int64_array_value (void) const { return int64NDArray (matrix); } 95 int64_array_value (void) const { return int64NDArray (m_matrix); }
96 96
97 uint8NDArray 97 uint8NDArray
98 uint8_array_value (void) const { return uint8NDArray (matrix); } 98 uint8_array_value (void) const { return uint8NDArray (m_matrix); }
99 99
100 uint16NDArray 100 uint16NDArray
101 uint16_array_value (void) const { return uint16NDArray (matrix); } 101 uint16_array_value (void) const { return uint16NDArray (m_matrix); }
102 102
103 uint32NDArray 103 uint32NDArray
104 uint32_array_value (void) const { return uint32NDArray (matrix); } 104 uint32_array_value (void) const { return uint32NDArray (m_matrix); }
105 105
106 uint64NDArray 106 uint64NDArray
107 uint64_array_value (void) const { return uint64NDArray (matrix); } 107 uint64_array_value (void) const { return uint64NDArray (m_matrix); }
108 108
109 double 109 double
110 double_value (bool = false) const 110 double_value (bool = false) const
111 { 111 {
112 double retval; 112 double retval;
115 err_invalid_conversion (type_name (), "real scalar"); 115 err_invalid_conversion (type_name (), "real scalar");
116 116
117 warn_implicit_conversion ("Octave:array-to-scalar", 117 warn_implicit_conversion ("Octave:array-to-scalar",
118 type_name (), "real scalar"); 118 type_name (), "real scalar");
119 119
120 retval = matrix(0).double_value (); 120 retval = m_matrix(0).double_value ();
121 121
122 return retval; 122 return retval;
123 } 123 }
124 124
125 float 125 float
131 err_invalid_conversion (type_name (), "real scalar"); 131 err_invalid_conversion (type_name (), "real scalar");
132 132
133 warn_implicit_conversion ("Octave:array-to-scalar", 133 warn_implicit_conversion ("Octave:array-to-scalar",
134 type_name (), "real scalar"); 134 type_name (), "real scalar");
135 135
136 retval = matrix(0).float_value (); 136 retval = m_matrix(0).float_value ();
137 137
138 return retval; 138 return retval;
139 } 139 }
140 140
141 double scalar_value (bool = false) const { return double_value (); } 141 double scalar_value (bool = false) const { return double_value (); }
150 if (dv.ndims () > 2) 150 if (dv.ndims () > 2)
151 error ("invalid conversion of %s to Matrix", type_name ().c_str ()); 151 error ("invalid conversion of %s to Matrix", type_name ().c_str ());
152 152
153 retval = Matrix (dv(0), dv(1)); 153 retval = Matrix (dv(0), dv(1));
154 double *vec = retval.fortran_vec (); 154 double *vec = retval.fortran_vec ();
155 octave_idx_type nel = matrix.numel (); 155 octave_idx_type nel = m_matrix.numel ();
156 for (octave_idx_type i = 0; i < nel; i++) 156 for (octave_idx_type i = 0; i < nel; i++)
157 vec[i] = matrix(i).double_value (); 157 vec[i] = m_matrix(i).double_value ();
158 158
159 return retval; 159 return retval;
160 } 160 }
161 161
162 FloatMatrix 162 FloatMatrix
167 if (dv.ndims () > 2) 167 if (dv.ndims () > 2)
168 error ("invalid conversion of %s to FloatMatrix", type_name ().c_str ()); 168 error ("invalid conversion of %s to FloatMatrix", type_name ().c_str ());
169 169
170 retval = FloatMatrix (dv(0), dv(1)); 170 retval = FloatMatrix (dv(0), dv(1));
171 float *vec = retval.fortran_vec (); 171 float *vec = retval.fortran_vec ();
172 octave_idx_type nel = matrix.numel (); 172 octave_idx_type nel = m_matrix.numel ();
173 for (octave_idx_type i = 0; i < nel; i++) 173 for (octave_idx_type i = 0; i < nel; i++)
174 vec[i] = matrix(i).float_value (); 174 vec[i] = m_matrix(i).float_value ();
175 175
176 return retval; 176 return retval;
177 } 177 }
178 178
179 ComplexMatrix 179 ComplexMatrix
184 if (dv.ndims () > 2) 184 if (dv.ndims () > 2)
185 error ("invalid conversion of %s to Matrix", type_name ().c_str ()); 185 error ("invalid conversion of %s to Matrix", type_name ().c_str ());
186 186
187 retval = ComplexMatrix (dv(0), dv(1)); 187 retval = ComplexMatrix (dv(0), dv(1));
188 Complex *vec = retval.fortran_vec (); 188 Complex *vec = retval.fortran_vec ();
189 octave_idx_type nel = matrix.numel (); 189 octave_idx_type nel = m_matrix.numel ();
190 for (octave_idx_type i = 0; i < nel; i++) 190 for (octave_idx_type i = 0; i < nel; i++)
191 vec[i] = Complex (matrix(i).double_value ()); 191 vec[i] = Complex (m_matrix(i).double_value ());
192 192
193 return retval; 193 return retval;
194 } 194 }
195 195
196 FloatComplexMatrix 196 FloatComplexMatrix
201 if (dv.ndims () > 2) 201 if (dv.ndims () > 2)
202 error ("invalid conversion of %s to FloatMatrix", type_name ().c_str ()); 202 error ("invalid conversion of %s to FloatMatrix", type_name ().c_str ());
203 203
204 retval = FloatComplexMatrix (dv(0), dv(1)); 204 retval = FloatComplexMatrix (dv(0), dv(1));
205 FloatComplex *vec = retval.fortran_vec (); 205 FloatComplex *vec = retval.fortran_vec ();
206 octave_idx_type nel = matrix.numel (); 206 octave_idx_type nel = m_matrix.numel ();
207 for (octave_idx_type i = 0; i < nel; i++) 207 for (octave_idx_type i = 0; i < nel; i++)
208 vec[i] = FloatComplex (matrix(i).float_value ()); 208 vec[i] = FloatComplex (m_matrix(i).float_value ());
209 209
210 return retval; 210 return retval;
211 } 211 }
212 212
213 NDArray 213 NDArray
214 array_value (bool = false) const 214 array_value (bool = false) const
215 { 215 {
216 NDArray retval (matrix.dims ()); 216 NDArray retval (m_matrix.dims ());
217 double *vec = retval.fortran_vec (); 217 double *vec = retval.fortran_vec ();
218 octave_idx_type nel = matrix.numel (); 218 octave_idx_type nel = m_matrix.numel ();
219 for (octave_idx_type i = 0; i < nel; i++) 219 for (octave_idx_type i = 0; i < nel; i++)
220 vec[i] = matrix(i).double_value (); 220 vec[i] = m_matrix(i).double_value ();
221 return retval; 221 return retval;
222 } 222 }
223 223
224 FloatNDArray 224 FloatNDArray
225 float_array_value (bool = false) const 225 float_array_value (bool = false) const
226 { 226 {
227 FloatNDArray retval (matrix.dims ()); 227 FloatNDArray retval (m_matrix.dims ());
228 float *vec = retval.fortran_vec (); 228 float *vec = retval.fortran_vec ();
229 octave_idx_type nel = matrix.numel (); 229 octave_idx_type nel = m_matrix.numel ();
230 for (octave_idx_type i = 0; i < nel; i++) 230 for (octave_idx_type i = 0; i < nel; i++)
231 vec[i] = matrix(i).float_value (); 231 vec[i] = m_matrix(i).float_value ();
232 return retval; 232 return retval;
233 } 233 }
234 234
235 ComplexNDArray 235 ComplexNDArray
236 complex_array_value (bool = false) const 236 complex_array_value (bool = false) const
237 { 237 {
238 ComplexNDArray retval (matrix.dims ()); 238 ComplexNDArray retval (m_matrix.dims ());
239 Complex *vec = retval.fortran_vec (); 239 Complex *vec = retval.fortran_vec ();
240 octave_idx_type nel = matrix.numel (); 240 octave_idx_type nel = m_matrix.numel ();
241 for (octave_idx_type i = 0; i < nel; i++) 241 for (octave_idx_type i = 0; i < nel; i++)
242 vec[i] = Complex (matrix(i).double_value ()); 242 vec[i] = Complex (m_matrix(i).double_value ());
243 return retval; 243 return retval;
244 } 244 }
245 245
246 FloatComplexNDArray 246 FloatComplexNDArray
247 float_complex_array_value (bool = false) const 247 float_complex_array_value (bool = false) const
248 { 248 {
249 FloatComplexNDArray retval (matrix.dims ()); 249 FloatComplexNDArray retval (m_matrix.dims ());
250 FloatComplex *vec = retval.fortran_vec (); 250 FloatComplex *vec = retval.fortran_vec ();
251 octave_idx_type nel = matrix.numel (); 251 octave_idx_type nel = m_matrix.numel ();
252 for (octave_idx_type i = 0; i < nel; i++) 252 for (octave_idx_type i = 0; i < nel; i++)
253 vec[i] = FloatComplex (matrix(i).float_value ()); 253 vec[i] = FloatComplex (m_matrix(i).float_value ());
254 return retval; 254 return retval;
255 } 255 }
256 256
257 boolNDArray 257 boolNDArray
258 bool_array_value (bool warn = false) const 258 bool_array_value (bool warn = false) const
259 { 259 {
260 boolNDArray retval (dims ()); 260 boolNDArray retval (dims ());
261 261
262 octave_idx_type nel = numel (); 262 octave_idx_type nel = numel ();
263 263
264 if (warn && matrix.any_element_not_one_or_zero ()) 264 if (warn && m_matrix.any_element_not_one_or_zero ())
265 warn_logical_conversion (); 265 warn_logical_conversion ();
266 266
267 bool *vec = retval.fortran_vec (); 267 bool *vec = retval.fortran_vec ();
268 for (octave_idx_type i = 0; i < nel; i++) 268 for (octave_idx_type i = 0; i < nel; i++)
269 vec[i] = matrix(i).bool_value (); 269 vec[i] = m_matrix(i).bool_value ();
270 270
271 return retval; 271 return retval;
272 } 272 }
273 273
274 charNDArray 274 charNDArray
278 278
279 octave_idx_type nel = numel (); 279 octave_idx_type nel = numel ();
280 280
281 char *vec = retval.fortran_vec (); 281 char *vec = retval.fortran_vec ();
282 for (octave_idx_type i = 0; i < nel; i++) 282 for (octave_idx_type i = 0; i < nel; i++)
283 vec[i] = matrix(i).char_value (); 283 vec[i] = m_matrix(i).char_value ();
284 284
285 return retval; 285 return retval;
286 } 286 }
287 287
288 // Use matrix_ref here to clear index cache. 288 // Use matrix_ref here to clear index cache.
301 matrix_ref ().changesign (); 301 matrix_ref ().changesign ();
302 } 302 }
303 303
304 octave::idx_vector index_vector (bool /* require_integers */ = false) const 304 octave::idx_vector index_vector (bool /* require_integers */ = false) const
305 { 305 {
306 return idx_cache ? *idx_cache : set_idx_cache (octave::idx_vector (matrix)); 306 return m_idx_cache ? *m_idx_cache
307 : set_idx_cache (octave::idx_vector (m_matrix));
307 } 308 }
308 309
309 int write (octave::stream& os, int block_size, 310 int write (octave::stream& os, int block_size,
310 oct_data_conv::data_type output_type, int skip, 311 oct_data_conv::data_type output_type, int skip,
311 octave::mach_info::float_format flt_fmt) const 312 octave::mach_info::float_format flt_fmt) const
312 { return os.write (matrix, block_size, output_type, skip, flt_fmt); } 313 { return os.write (m_matrix, block_size, output_type, skip, flt_fmt); }
313 314
314 mxArray * as_mxArray (bool interleaved) const 315 mxArray * as_mxArray (bool interleaved) const
315 { 316 {
316 mxArray *retval = new mxArray (interleaved, OCTAVE_INT_MX_CLASS, dims (), 317 mxArray *retval = new mxArray (interleaved, OCTAVE_INT_MX_CLASS, dims (),
317 mxREAL); 318 mxREAL);
319 OCTAVE_INT_T::val_type *pd 320 OCTAVE_INT_T::val_type *pd
320 = static_cast<OCTAVE_INT_T::val_type *> (retval->get_data ()); 321 = static_cast<OCTAVE_INT_T::val_type *> (retval->get_data ());
321 322
322 mwSize nel = numel (); 323 mwSize nel = numel ();
323 324
324 const OCTAVE_INT_T *pdata = matrix.data (); 325 const OCTAVE_INT_T *pdata = m_matrix.data ();
325 326
326 for (mwIndex i = 0; i < nel; i++) 327 for (mwIndex i = 0; i < nel; i++)
327 pd[i] = pdata[i].value (); 328 pd[i] = pdata[i].value ();
328 329
329 return retval; 330 return retval;
332 octave_value map (unary_mapper_t umap) const 333 octave_value map (unary_mapper_t umap) const
333 { 334 {
334 switch (umap) 335 switch (umap)
335 { 336 {
336 case umap_abs: 337 case umap_abs:
337 return matrix.abs (); 338 return m_matrix.abs ();
338 case umap_signum: 339 case umap_signum:
339 return matrix.signum (); 340 return m_matrix.signum ();
340 case umap_ceil: 341 case umap_ceil:
341 case umap_conj: 342 case umap_conj:
342 case umap_fix: 343 case umap_fix:
343 case umap_floor: 344 case umap_floor:
344 case umap_real: 345 case umap_real:
345 case umap_round: 346 case umap_round:
346 return matrix; 347 return m_matrix;
347 case umap_imag: 348 case umap_imag:
348 return intNDArray<OCTAVE_INT_T> (matrix.dims (), OCTAVE_INT_T ()); 349 return intNDArray<OCTAVE_INT_T> (m_matrix.dims (), OCTAVE_INT_T ());
349 case umap_isnan: 350 case umap_isnan:
350 case umap_isna: 351 case umap_isna:
351 case umap_isinf: 352 case umap_isinf:
352 return boolNDArray (matrix.dims (), false); 353 return boolNDArray (m_matrix.dims (), false);
353 case umap_isfinite: 354 case umap_isfinite:
354 return boolNDArray (matrix.dims (), true); 355 return boolNDArray (m_matrix.dims (), true);
355 356
356 // Special cases for Matlab compatibility. 357 // Special cases for Matlab compatibility.
357 case umap_xtolower: 358 case umap_xtolower:
358 case umap_xtoupper: 359 case umap_xtoupper:
359 return matrix; 360 return m_matrix;
360 361
361 default: 362 default:
362 { 363 {
363 // FIXME: we should be able to do better than converting to 364 // FIXME: we should be able to do better than converting to
364 // double here. 365 // double here.