Mercurial > octave

comparison libinterp/octave-value/ov-ch-mat.cc @ 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 83f9f8bda883
children aac27ad79be6
comparison
equal deleted inserted replaced
31137:6308ce73bdca 31138:b3ca7f891750
58 template class octave_base_matrix<charNDArray>; 58 template class octave_base_matrix<charNDArray>;
59 59
60 octave::idx_vector 60 octave::idx_vector
61 octave_char_matrix::index_vector (bool /* require_integers */) const 61 octave_char_matrix::index_vector (bool /* require_integers */) const
62 { 62 {
63 const char *p = matrix.data (); 63 const char *p = m_matrix.data ();
64 if (numel () == 1 && *p == ':') 64 if (numel () == 1 && *p == ':')
65 return octave::idx_vector (':'); 65 return octave::idx_vector (':');
66 else 66 else
67 return octave::idx_vector (array_value (true)); 67 return octave::idx_vector (array_value (true));
68 } 68 }
74 err_invalid_conversion ("character matrix", "real scalar"); 74 err_invalid_conversion ("character matrix", "real scalar");
75 75
76 warn_implicit_conversion ("Octave:array-to-scalar", 76 warn_implicit_conversion ("Octave:array-to-scalar",
77 "character matrix", "real scalar"); 77 "character matrix", "real scalar");
78 78
79 return static_cast<unsigned char> (matrix(0, 0)); 79 return static_cast<unsigned char> (m_matrix(0, 0));
80 } 80 }
81 81
82 float 82 float
83 octave_char_matrix::float_value (bool) const 83 octave_char_matrix::float_value (bool) const
84 { 84 {
86 err_invalid_conversion ("character matrix", "real scalar"); 86 err_invalid_conversion ("character matrix", "real scalar");
87 87
88 warn_implicit_conversion ("Octave:array-to-scalar", 88 warn_implicit_conversion ("Octave:array-to-scalar",
89 "character matrix", "real scalar"); 89 "character matrix", "real scalar");
90 90
91 return static_cast<unsigned char> (matrix(0, 0)); 91 return static_cast<unsigned char> (m_matrix(0, 0));
92 } 92 }
93 93
94 octave_int64 94 octave_int64
95 octave_char_matrix::int64_scalar_value () const 95 octave_char_matrix::int64_scalar_value () const
96 { 96 {
100 err_invalid_conversion ("character matrix", "int64 scalar"); 100 err_invalid_conversion ("character matrix", "int64 scalar");
101 101
102 warn_implicit_conversion ("Octave:array-to-scalar", 102 warn_implicit_conversion ("Octave:array-to-scalar",
103 "character matrix", "int64 scalar"); 103 "character matrix", "int64 scalar");
104 104
105 retval = octave_int64 (matrix(0, 0)); 105 retval = octave_int64 (m_matrix(0, 0));
106 106
107 return retval; 107 return retval;
108 } 108 }
109 109
110 octave_uint64 110 octave_uint64
116 err_invalid_conversion ("character matrix", "uint64 scalar"); 116 err_invalid_conversion ("character matrix", "uint64 scalar");
117 117
118 warn_implicit_conversion ("Octave:array-to-scalar", 118 warn_implicit_conversion ("Octave:array-to-scalar",
119 "character matrix", "uint64 scalar"); 119 "character matrix", "uint64 scalar");
120 120
121 retval = octave_uint64 (matrix(0, 0)); 121 retval = octave_uint64 (m_matrix(0, 0));
122 122
123 return retval; 123 return retval;
124 } 124 }
125 125
126 Complex 126 Complex
130 err_invalid_conversion ("character matrix", "complex scalar"); 130 err_invalid_conversion ("character matrix", "complex scalar");
131 131
132 warn_implicit_conversion ("Octave:array-to-scalar", 132 warn_implicit_conversion ("Octave:array-to-scalar",
133 "character matrix", "complex scalar"); 133 "character matrix", "complex scalar");
134 134
135 return Complex (static_cast<unsigned char> (matrix(0, 0)), 0); 135 return Complex (static_cast<unsigned char> (m_matrix(0, 0)), 0);
136 } 136 }
137 137
138 FloatComplex 138 FloatComplex
139 octave_char_matrix::float_complex_value (bool) const 139 octave_char_matrix::float_complex_value (bool) const
140 { 140 {
146 err_invalid_conversion ("character matrix", "complex scalar"); 146 err_invalid_conversion ("character matrix", "complex scalar");
147 147
148 warn_implicit_conversion ("Octave:array-to-scalar", 148 warn_implicit_conversion ("Octave:array-to-scalar",
149 "character matrix", "complex scalar"); 149 "character matrix", "complex scalar");
150 150
151 retval = static_cast<unsigned char> (matrix(0, 0)); 151 retval = static_cast<unsigned char> (m_matrix(0, 0));
152 152
153 return retval; 153 return retval;
154 } 154 }
155 155
156 octave_value 156 octave_value
157 octave_char_matrix::as_double (void) const 157 octave_char_matrix::as_double (void) const
158 { 158 {
159 return NDArray (matrix); 159 return NDArray (m_matrix);
160 } 160 }
161 161
162 octave_value 162 octave_value
163 octave_char_matrix::as_single (void) const 163 octave_char_matrix::as_single (void) const
164 { 164 {
165 return FloatNDArray (matrix); 165 return FloatNDArray (m_matrix);
166 } 166 }
167 167
168 octave_value 168 octave_value
169 octave_char_matrix::as_int8 (void) const 169 octave_char_matrix::as_int8 (void) const
170 { 170 {
171 return int8NDArray (matrix); 171 return int8NDArray (m_matrix);
172 } 172 }
173 173
174 octave_value 174 octave_value
175 octave_char_matrix::as_int16 (void) const 175 octave_char_matrix::as_int16 (void) const
176 { 176 {
177 return int16NDArray (matrix); 177 return int16NDArray (m_matrix);
178 } 178 }
179 179
180 octave_value 180 octave_value
181 octave_char_matrix::as_int32 (void) const 181 octave_char_matrix::as_int32 (void) const
182 { 182 {
183 return int32NDArray (matrix); 183 return int32NDArray (m_matrix);
184 } 184 }
185 185
186 octave_value 186 octave_value
187 octave_char_matrix::as_int64 (void) const 187 octave_char_matrix::as_int64 (void) const
188 { 188 {
189 return int64NDArray (matrix); 189 return int64NDArray (m_matrix);
190 } 190 }
191 191
192 octave_value 192 octave_value
193 octave_char_matrix::as_uint8 (void) const 193 octave_char_matrix::as_uint8 (void) const
194 { 194 {
195 return uint8NDArray (matrix); 195 return uint8NDArray (m_matrix);
196 } 196 }
197 197
198 octave_value 198 octave_value
199 octave_char_matrix::as_uint16 (void) const 199 octave_char_matrix::as_uint16 (void) const
200 { 200 {
201 return uint16NDArray (matrix); 201 return uint16NDArray (m_matrix);
202 } 202 }
203 203
204 octave_value 204 octave_value
205 octave_char_matrix::as_uint32 (void) const 205 octave_char_matrix::as_uint32 (void) const
206 { 206 {
207 return uint32NDArray (matrix); 207 return uint32NDArray (m_matrix);
208 } 208 }
209 209
210 octave_value 210 octave_value
211 octave_char_matrix::as_uint64 (void) const 211 octave_char_matrix::as_uint64 (void) const
212 { 212 {
213 return uint64NDArray (matrix); 213 return uint64NDArray (m_matrix);
214 } 214 }
215 215
216 void 216 void
217 octave_char_matrix::print_raw (std::ostream& os, 217 octave_char_matrix::print_raw (std::ostream& os,
218 bool pr_as_read_syntax) const 218 bool pr_as_read_syntax) const
219 { 219 {
220 octave_print_internal (os, matrix, pr_as_read_syntax, 220 octave_print_internal (os, m_matrix, pr_as_read_syntax,
221 current_print_indent_level ()); 221 current_print_indent_level ());
222 } 222 }
223 223
224 mxArray * 224 mxArray *
225 octave_char_matrix::as_mxArray (bool interleaved) const 225 octave_char_matrix::as_mxArray (bool interleaved) const
228 228
229 mxChar *pd = static_cast<mxChar *> (retval->get_data ()); 229 mxChar *pd = static_cast<mxChar *> (retval->get_data ());
230 230
231 mwSize nel = numel (); 231 mwSize nel = numel ();
232 232
233 const char *pdata = matrix.data (); 233 const char *pdata = m_matrix.data ();
234 234
235 for (mwIndex i = 0; i < nel; i++) 235 for (mwIndex i = 0; i < nel; i++)
236 pd[i] = pdata[i]; 236 pd[i] = pdata[i];
237 237
238 return retval; 238 return retval;
259 259
260 switch (umap) 260 switch (umap)
261 { 261 {
262 #define STRING_MAPPER(UMAP,FCN,TYPE) \ 262 #define STRING_MAPPER(UMAP,FCN,TYPE) \
263 case umap_ ## UMAP: \ 263 case umap_ ## UMAP: \
264 return octave_value (matrix.map<TYPE, int (&) (int)> (FCN)) 264 return octave_value (m_matrix.map<TYPE, int (&) (int)> (FCN))
265 265
266 STRING_MAPPER (xisascii, xisascii, bool); 266 STRING_MAPPER (xisascii, xisascii, bool);
267 267
268 #define STRING_U8_MAPPER(UMAP,FCN) \ 268 #define STRING_U8_MAPPER(UMAP,FCN) \
269 case umap_ ## UMAP: \ 269 case umap_ ## UMAP: \
270 { \ 270 { \
271 charNDArray in_m = matrix; \ 271 charNDArray in_m = m_matrix; \
272 Array<octave_idx_type> p (dim_vector (matrix.ndims (), 1)); \ 272 Array<octave_idx_type> p (dim_vector (m_matrix.ndims (), 1)); \
273 if (matrix.ndims () > 1) \ 273 if (m_matrix.ndims () > 1) \
274 { \ 274 { \
275 for (octave_idx_type i=0; i < matrix.ndims (); i++) \ 275 for (octave_idx_type i=0; i < m_matrix.ndims (); i++) \
276 p(i) = i; \ 276 p(i) = i; \
277 p(0) = 1; \ 277 p(0) = 1; \
278 p(1) = 0; \ 278 p(1) = 0; \
279 in_m = matrix.permute (p); \ 279 in_m = m_matrix.permute (p); \
280 } \ 280 } \
281 boolNDArray b_array = boolNDArray (in_m.dims ()); \ 281 boolNDArray b_array = boolNDArray (in_m.dims ()); \
282 const uint8_t *in = reinterpret_cast<const uint8_t *> (in_m.data ()); \ 282 const uint8_t *in = reinterpret_cast<const uint8_t *> (in_m.data ()); \
283 uint32_t uc; \ 283 uint32_t uc; \
284 for (octave_idx_type i = 0; i < in_m.numel (); ) \ 284 for (octave_idx_type i = 0; i < in_m.numel (); ) \
289 bool is_upper = FCN (uc); \ 289 bool is_upper = FCN (uc); \
290 for (int j = 0; j < mblen; j++) \ 290 for (int j = 0; j < mblen; j++) \
291 b_array(i+j) = is_upper; \ 291 b_array(i+j) = is_upper; \
292 i += mblen; \ 292 i += mblen; \
293 } \ 293 } \
294 return octave_value ((matrix.ndims () > 1) ? b_array.permute (p, true) \ 294 return octave_value ((m_matrix.ndims () > 1) ? b_array.permute (p, true) \
295 : b_array); \ 295 : b_array); \
296 } 296 }
297 297
298 STRING_U8_MAPPER (xisalnum, octave_uc_is_alnum_wrapper); 298 STRING_U8_MAPPER (xisalnum, octave_uc_is_alnum_wrapper);
299 STRING_U8_MAPPER (xisalpha, octave_uc_is_alpha_wrapper); 299 STRING_U8_MAPPER (xisalpha, octave_uc_is_alpha_wrapper);
300 STRING_U8_MAPPER (xiscntrl, octave_uc_is_cntrl_wrapper); 300 STRING_U8_MAPPER (xiscntrl, octave_uc_is_cntrl_wrapper);
308 STRING_U8_MAPPER (xisxdigit, octave_uc_is_xdigit_wrapper); 308 STRING_U8_MAPPER (xisxdigit, octave_uc_is_xdigit_wrapper);
309 309
310 #define STRING_U8_FCN(UMAP,U8_FCN,STD_FCN) \ 310 #define STRING_U8_FCN(UMAP,U8_FCN,STD_FCN) \
311 case umap_ ## UMAP: \ 311 case umap_ ## UMAP: \
312 { \ 312 { \
313 charNDArray in_m = matrix; \ 313 charNDArray in_m = m_matrix; \
314 Array<octave_idx_type> p (dim_vector (matrix.ndims (), 1)); \ 314 Array<octave_idx_type> p (dim_vector (m_matrix.ndims (), 1)); \
315 if (matrix.ndims () > 1) \ 315 if (m_matrix.ndims () > 1) \
316 { \ 316 { \
317 for (octave_idx_type i=0; i < matrix.ndims (); i++) \ 317 for (octave_idx_type i=0; i < m_matrix.ndims (); i++) \
318 p(i) = i; \ 318 p(i) = i; \
319 p(0) = 1; \ 319 p(0) = 1; \
320 p(1) = 0; \ 320 p(1) = 0; \
321 in_m = matrix.permute (p); \ 321 in_m = m_matrix.permute (p); \
322 } \ 322 } \
323 std::size_t output_length = in_m.numel (); \ 323 std::size_t output_length = in_m.numel (); \
324 charNDArray ch_array = charNDArray (in_m.dims ()); \ 324 charNDArray ch_array = charNDArray (in_m.dims ()); \
325 const uint8_t *in = reinterpret_cast<const uint8_t *> (in_m.data ()); \ 325 const uint8_t *in = reinterpret_cast<const uint8_t *> (in_m.data ()); \
326 uint8_t *buf = reinterpret_cast<uint8_t *> (ch_array.fortran_vec ()); \ 326 uint8_t *buf = reinterpret_cast<uint8_t *> (ch_array.fortran_vec ()); \
327 U8_FCN (in, matrix.numel (), nullptr, buf, &output_length); \ 327 U8_FCN (in, m_matrix.numel (), nullptr, buf, &output_length); \
328 if (output_length != static_cast<std::size_t> (matrix.numel ())) \ 328 if (output_length != static_cast<std::size_t> (m_matrix.numel ())) \
329 { \ 329 { \
330 warning_with_id ("Octave:multi_byte_char_length", \ 330 warning_with_id ("Octave:multi_byte_char_length", \
331 "UMAP: Possible multi-byte error."); \ 331 "UMAP: Possible multi-byte error."); \
332 return octave_value (matrix.map<char, int (&) (int)> (STD_FCN)); \ 332 return octave_value (m_matrix.map<char, int (&) (int)> (STD_FCN)); \
333 } \ 333 } \
334 return octave_value ((matrix.ndims () > 1) ? ch_array.permute (p, true)\ 334 return octave_value ((m_matrix.ndims () > 1) ? ch_array.permute (p, true)\
335 : ch_array); \ 335 : ch_array); \
336 } 336 }
337 337
338 STRING_U8_FCN (xtolower, octave_u8_tolower_wrapper, std::tolower); 338 STRING_U8_FCN (xtolower, octave_u8_tolower_wrapper, std::tolower);
339 STRING_U8_FCN (xtoupper, octave_u8_toupper_wrapper, std::toupper); 339 STRING_U8_FCN (xtoupper, octave_u8_toupper_wrapper, std::toupper);
340 340