GNU Octave  4.4.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
pt-mat.cc
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 1996-2018 John W. Eaton
4 
5 This file is part of Octave.
6 
7 Octave is free software: you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11 
12 Octave is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16 
17 You should have received a copy of the GNU General Public License
18 along with Octave; see the file COPYING. If not, see
19 <https://www.gnu.org/licenses/>.
20 
21 */
22 
23 #if defined (HAVE_CONFIG_H)
24 # include "config.h"
25 #endif
26 
27 #include "defun.h"
28 #include "ovl.h"
29 #include "pt-arg-list.h"
30 #include "pt-exp.h"
31 #include "pt-mat.h"
32 #include "pt-tm-const.h"
33 #include "ov.h"
34 #include "variables.h"
35 
36 #include "ov-cx-mat.h"
37 #include "ov-flt-cx-mat.h"
38 #include "ov-re-sparse.h"
39 #include "ov-cx-sparse.h"
40 
41 namespace octave
42 {
43  std::string
44  get_concat_class (const std::string& c1, const std::string& c2)
45  {
46  std::string retval = octave_base_value::static_class_name ();
47 
48  if (c1 == c2)
49  retval = c1;
50  else if (c1.empty ())
51  retval = c2;
52  else if (c2.empty ())
53  retval = c1;
54  else if (c1 == "class" || c2 == "class")
55  retval = "class";
56  else
57  {
58  bool c1_is_int = (c1 == "int8" || c1 == "uint8"
59  || c1 == "int16" || c1 == "uint16"
60  || c1 == "int32" || c1 == "uint32"
61  || c1 == "int64" || c1 == "uint64");
62  bool c2_is_int = (c2 == "int8" || c2 == "uint8"
63  || c2 == "int16" || c2 == "uint16"
64  || c2 == "int32" || c2 == "uint32"
65  || c2 == "int64" || c2 == "uint64");
66 
67  bool c1_is_char = (c1 == "char");
68  bool c2_is_char = (c2 == "char");
69 
70  bool c1_is_double = (c1 == "double");
71  bool c2_is_double = (c2 == "double");
72 
73  bool c1_is_single = (c1 == "single");
74  bool c2_is_single = (c2 == "single");
75 
76  bool c1_is_logical = (c1 == "logical");
77  bool c2_is_logical = (c2 == "logical");
78 
79  bool c1_is_built_in_type
80  = (c1_is_int || c1_is_char || c1_is_double || c1_is_single
81  || c1_is_logical);
82 
83  bool c2_is_built_in_type
84  = (c2_is_int || c2_is_char || c2_is_double || c2_is_single
85  || c2_is_logical);
86 
87  // Order is important here...
88 
89  if (c1 == "struct" && c2 == c1)
90  retval = c1;
91  else if (c1 == "cell" || c2 == "cell")
92  retval = "cell";
93  else if (c1_is_char && c2_is_built_in_type)
94  retval = c1;
95  else if (c2_is_char && c1_is_built_in_type)
96  retval = c2;
97  else if (c1_is_int && c2_is_built_in_type)
98  retval = c1;
99  else if (c2_is_int && c1_is_built_in_type)
100  retval = c2;
101  else if (c1_is_single && c2_is_built_in_type)
102  retval = c1;
103  else if (c2_is_single && c1_is_built_in_type)
104  retval = c2;
105  else if (c1_is_double && c2_is_built_in_type)
106  retval = c1;
107  else if (c2_is_double && c1_is_built_in_type)
108  retval = c2;
109  else if (c1_is_logical && c2_is_logical)
110  retval = c1;
111  }
112 
113  return retval;
114  }
115 
116  void
117  maybe_warn_string_concat (bool all_dq_strings_p, bool all_sq_strings_p)
118  {
119  if (! (all_dq_strings_p || all_sq_strings_p))
120  warning_with_id ("Octave:mixed-string-concat",
121  "concatenation of different character string types may have unintended consequences");
122  }
123 
124  tree_expression *
125  tree_matrix::dup (symbol_scope& scope) const
126  {
127  tree_matrix *new_matrix = new tree_matrix (nullptr, line (), column ());
128 
129  new_matrix->copy_base (*this, scope);
130 
131  return new_matrix;
132  }
133 }
134 
135 
136 /*
137 ## test concatenation with all zero matrices
138 %!assert ([ "" 65*ones(1,10) ], "AAAAAAAAAA")
139 %!assert ([ 65*ones(1,10) "" ], "AAAAAAAAAA")
140 
141 %!test
142 %! c = {"foo"; "bar"; "bazoloa"};
143 %! assert ([c; "a"; "bc"; "def"], {"foo"; "bar"; "bazoloa"; "a"; "bc"; "def"});
144 
145 %!assert (class ([int64(1), int64(1)]), "int64")
146 %!assert (class ([int64(1), int32(1)]), "int64")
147 %!assert (class ([int64(1), int16(1)]), "int64")
148 %!assert (class ([int64(1), int8(1)]), "int64")
149 %!assert (class ([int64(1), uint64(1)]), "int64")
150 %!assert (class ([int64(1), uint32(1)]), "int64")
151 %!assert (class ([int64(1), uint16(1)]), "int64")
152 %!assert (class ([int64(1), uint8(1)]), "int64")
153 %!assert (class ([int64(1), single(1)]), "int64")
154 %!assert (class ([int64(1), double(1)]), "int64")
155 %!assert (class ([int64(1), cell(1)]), "cell")
156 %!assert (class ([int64(1), true]), "int64")
157 %!assert (class ([int64(1), "a"]), "char")
158 
159 %!assert (class ([int32(1), int64(1)]), "int32")
160 %!assert (class ([int32(1), int32(1)]), "int32")
161 %!assert (class ([int32(1), int16(1)]), "int32")
162 %!assert (class ([int32(1), int8(1)]), "int32")
163 %!assert (class ([int32(1), uint64(1)]), "int32")
164 %!assert (class ([int32(1), uint32(1)]), "int32")
165 %!assert (class ([int32(1), uint16(1)]), "int32")
166 %!assert (class ([int32(1), uint8(1)]), "int32")
167 %!assert (class ([int32(1), single(1)]), "int32")
168 %!assert (class ([int32(1), double(1)]), "int32")
169 %!assert (class ([int32(1), cell(1)]), "cell")
170 %!assert (class ([int32(1), true]), "int32")
171 %!assert (class ([int32(1), "a"]), "char")
172 
173 %!assert (class ([int16(1), int64(1)]), "int16")
174 %!assert (class ([int16(1), int32(1)]), "int16")
175 %!assert (class ([int16(1), int16(1)]), "int16")
176 %!assert (class ([int16(1), int8(1)]), "int16")
177 %!assert (class ([int16(1), uint64(1)]), "int16")
178 %!assert (class ([int16(1), uint32(1)]), "int16")
179 %!assert (class ([int16(1), uint16(1)]), "int16")
180 %!assert (class ([int16(1), uint8(1)]), "int16")
181 %!assert (class ([int16(1), single(1)]), "int16")
182 %!assert (class ([int16(1), double(1)]), "int16")
183 %!assert (class ([int16(1), cell(1)]), "cell")
184 %!assert (class ([int16(1), true]), "int16")
185 %!assert (class ([int16(1), "a"]), "char")
186 
187 %!assert (class ([int8(1), int64(1)]), "int8")
188 %!assert (class ([int8(1), int32(1)]), "int8")
189 %!assert (class ([int8(1), int16(1)]), "int8")
190 %!assert (class ([int8(1), int8(1)]), "int8")
191 %!assert (class ([int8(1), uint64(1)]), "int8")
192 %!assert (class ([int8(1), uint32(1)]), "int8")
193 %!assert (class ([int8(1), uint16(1)]), "int8")
194 %!assert (class ([int8(1), uint8(1)]), "int8")
195 %!assert (class ([int8(1), single(1)]), "int8")
196 %!assert (class ([int8(1), double(1)]), "int8")
197 %!assert (class ([int8(1), cell(1)]), "cell")
198 %!assert (class ([int8(1), true]), "int8")
199 %!assert (class ([int8(1), "a"]), "char")
200 
201 %!assert (class ([uint64(1), int64(1)]), "uint64")
202 %!assert (class ([uint64(1), int32(1)]), "uint64")
203 %!assert (class ([uint64(1), int16(1)]), "uint64")
204 %!assert (class ([uint64(1), int8(1)]), "uint64")
205 %!assert (class ([uint64(1), uint64(1)]), "uint64")
206 %!assert (class ([uint64(1), uint32(1)]), "uint64")
207 %!assert (class ([uint64(1), uint16(1)]), "uint64")
208 %!assert (class ([uint64(1), uint8(1)]), "uint64")
209 %!assert (class ([uint64(1), single(1)]), "uint64")
210 %!assert (class ([uint64(1), double(1)]), "uint64")
211 %!assert (class ([uint64(1), cell(1)]), "cell")
212 %!assert (class ([uint64(1), true]), "uint64")
213 %!assert (class ([uint64(1), "a"]), "char")
214 
215 %!assert (class ([uint32(1), int64(1)]), "uint32")
216 %!assert (class ([uint32(1), int32(1)]), "uint32")
217 %!assert (class ([uint32(1), int16(1)]), "uint32")
218 %!assert (class ([uint32(1), int8(1)]), "uint32")
219 %!assert (class ([uint32(1), uint64(1)]), "uint32")
220 %!assert (class ([uint32(1), uint32(1)]), "uint32")
221 %!assert (class ([uint32(1), uint16(1)]), "uint32")
222 %!assert (class ([uint32(1), uint8(1)]), "uint32")
223 %!assert (class ([uint32(1), single(1)]), "uint32")
224 %!assert (class ([uint32(1), double(1)]), "uint32")
225 %!assert (class ([uint32(1), cell(1)]), "cell")
226 %!assert (class ([uint32(1), true]), "uint32")
227 %!assert (class ([uint32(1), "a"]), "char")
228 
229 %!assert (class ([uint16(1), int64(1)]), "uint16")
230 %!assert (class ([uint16(1), int32(1)]), "uint16")
231 %!assert (class ([uint16(1), int16(1)]), "uint16")
232 %!assert (class ([uint16(1), int8(1)]), "uint16")
233 %!assert (class ([uint16(1), uint64(1)]), "uint16")
234 %!assert (class ([uint16(1), uint32(1)]), "uint16")
235 %!assert (class ([uint16(1), uint16(1)]), "uint16")
236 %!assert (class ([uint16(1), uint8(1)]), "uint16")
237 %!assert (class ([uint16(1), single(1)]), "uint16")
238 %!assert (class ([uint16(1), double(1)]), "uint16")
239 %!assert (class ([uint16(1), cell(1)]), "cell")
240 %!assert (class ([uint16(1), true]), "uint16")
241 %!assert (class ([uint16(1), "a"]), "char")
242 
243 %!assert (class ([uint8(1), int64(1)]), "uint8")
244 %!assert (class ([uint8(1), int32(1)]), "uint8")
245 %!assert (class ([uint8(1), int16(1)]), "uint8")
246 %!assert (class ([uint8(1), int8(1)]), "uint8")
247 %!assert (class ([uint8(1), uint64(1)]), "uint8")
248 %!assert (class ([uint8(1), uint32(1)]), "uint8")
249 %!assert (class ([uint8(1), uint16(1)]), "uint8")
250 %!assert (class ([uint8(1), uint8(1)]), "uint8")
251 %!assert (class ([uint8(1), single(1)]), "uint8")
252 %!assert (class ([uint8(1), double(1)]), "uint8")
253 %!assert (class ([uint8(1), cell(1)]), "cell")
254 %!assert (class ([uint8(1), true]), "uint8")
255 %!assert (class ([uint8(1), "a"]), "char")
256 
257 %!assert (class ([single(1), int64(1)]), "int64")
258 %!assert (class ([single(1), int32(1)]), "int32")
259 %!assert (class ([single(1), int16(1)]), "int16")
260 %!assert (class ([single(1), int8(1)]), "int8")
261 %!assert (class ([single(1), uint64(1)]), "uint64")
262 %!assert (class ([single(1), uint32(1)]), "uint32")
263 %!assert (class ([single(1), uint16(1)]), "uint16")
264 %!assert (class ([single(1), uint8(1)]), "uint8")
265 %!assert (class ([single(1), single(1)]), "single")
266 %!assert (class ([single(1), double(1)]), "single")
267 %!assert (class ([single(1), cell(1)]), "cell")
268 %!assert (class ([single(1), true]), "single")
269 %!assert (class ([single(1), "a"]), "char")
270 
271 %!assert (class ([double(1), int64(1)]), "int64")
272 %!assert (class ([double(1), int32(1)]), "int32")
273 %!assert (class ([double(1), int16(1)]), "int16")
274 %!assert (class ([double(1), int8(1)]), "int8")
275 %!assert (class ([double(1), uint64(1)]), "uint64")
276 %!assert (class ([double(1), uint32(1)]), "uint32")
277 %!assert (class ([double(1), uint16(1)]), "uint16")
278 %!assert (class ([double(1), uint8(1)]), "uint8")
279 %!assert (class ([double(1), single(1)]), "single")
280 %!assert (class ([double(1), double(1)]), "double")
281 %!assert (class ([double(1), cell(1)]), "cell")
282 %!assert (class ([double(1), true]), "double")
283 %!assert (class ([double(1), "a"]), "char")
284 
285 %!assert (class ([cell(1), int64(1)]), "cell")
286 %!assert (class ([cell(1), int32(1)]), "cell")
287 %!assert (class ([cell(1), int16(1)]), "cell")
288 %!assert (class ([cell(1), int8(1)]), "cell")
289 %!assert (class ([cell(1), uint64(1)]), "cell")
290 %!assert (class ([cell(1), uint32(1)]), "cell")
291 %!assert (class ([cell(1), uint16(1)]), "cell")
292 %!assert (class ([cell(1), uint8(1)]), "cell")
293 %!assert (class ([cell(1), single(1)]), "cell")
294 %!assert (class ([cell(1), double(1)]), "cell")
295 %!assert (class ([cell(1), cell(1)]), "cell")
296 %!assert (class ([cell(1), true]), "cell")
297 %!assert (class ([cell(1), "a"]), "cell")
298 
299 %!assert (class ([true, int64(1)]), "int64")
300 %!assert (class ([true, int32(1)]), "int32")
301 %!assert (class ([true, int16(1)]), "int16")
302 %!assert (class ([true, int8(1)]), "int8")
303 %!assert (class ([true, uint64(1)]), "uint64")
304 %!assert (class ([true, uint32(1)]), "uint32")
305 %!assert (class ([true, uint16(1)]), "uint16")
306 %!assert (class ([true, uint8(1)]), "uint8")
307 %!assert (class ([true, single(1)]), "single")
308 %!assert (class ([true, double(1)]), "double")
309 %!assert (class ([true, cell(1)]), "cell")
310 %!assert (class ([true, true]), "logical")
311 %!assert (class ([true, "a"]), "char")
312 
313 %!assert (class (["a", int64(1)]), "char")
314 %!assert (class (["a", int32(1)]), "char")
315 %!assert (class (["a", int16(1)]), "char")
316 %!assert (class (["a", int8(1)]), "char")
317 %!assert (class (["a", int64(1)]), "char")
318 %!assert (class (["a", int32(1)]), "char")
319 %!assert (class (["a", int16(1)]), "char")
320 %!assert (class (["a", int8(1)]), "char")
321 %!assert (class (["a", single(1)]), "char")
322 %!assert (class (["a", double(1)]), "char")
323 %!assert (class (["a", cell(1)]), "cell")
324 %!assert (class (["a", true]), "char")
325 %!assert (class (["a", "a"]), "char")
326 
327 %!assert (class ([cell(1), struct("foo", "bar")]), "cell")
328 %!error [struct("foo", "bar"), cell(1)]
329 
330 %!test <*39041> assert (class ([cell(0), struct()]), "cell")
331 %!test <51086> assert (class ([struct(), cell(0)]), "struct")
332 
333 %!assert ([,1], 1)
334 %!assert ([1,], 1)
335 %!assert ([,1,], 1)
336 %!assert ([,1,;;], 1)
337 %!assert ([,1,;,;], 1)
338 
339 %!assert ([1,1], ones (1, 2))
340 %!assert ([,1,1], ones (1, 2))
341 %!assert ([1,1,], ones (1, 2))
342 %!assert ([,1,1,], ones (1, 2))
343 %!assert ([,1,1,;;], ones (1, 2))
344 %!assert ([,1,1,;,;], ones (1, 2))
345 %!assert ([,;,1,1], ones (1, 2))
346 
347 %!assert ([1;1], ones (2, 1))
348 %!assert ([1,;1], ones (2, 1))
349 %!assert ([1,;,;1], ones (2, 1))
350 
351 %!error eval ("[,,]")
352 %!error eval ("[,,;,]")
353 %!error eval ("[,;,,;,]")
354 
355 %!assert (isnull ([,]))
356 %!assert (isnull ([;]))
357 %!assert (isnull ([;;]))
358 %!assert (isnull ([;,;]))
359 %!assert (isnull ([,;,;,]))
360 */
octave::tree_array_list::copy_base
void copy_base(const tree_array_list &array_list)
Definition: pt-array-list.cc:75
warning_with_id
void warning_with_id(const char *id, const char *fmt,...)
Definition: error.cc:816
octave::tree::column
virtual int column(void) const
Definition: pt.h:58
octave_base_value::static_class_name
static std::string static_class_name(void)
Definition: ov-base.h:876
octave::tree_matrix
Definition: pt-mat.h:46
octave::maybe_warn_string_concat
void maybe_warn_string_concat(bool all_dq_strings_p, bool all_sq_strings_p)
Definition: pt-mat.cc:117
octave::symbol_scope
Definition: symscope.h:600
retval
octave_value retval
Definition: data.cc:6246
octave::tree_matrix::tree_matrix
tree_matrix(tree_argument_list *row=nullptr, int l=-1, int c=-1)
Definition: pt-mat.h:50
octave::get_concat_class
std::string get_concat_class(const std::string &c1, const std::string &c2)
Definition: pt-mat.cc:44
octave::tree_matrix::dup
tree_expression * dup(symbol_scope &scope) const
Definition: pt-mat.cc:125
string
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
Definition: utils.cc:888