Mercurial > hg > octave-lojdl
annotate src/ov-typeinfo.cc @ 14429:eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
* data.cc, defaults.cc, dirfns.cc, file-io.cc, graphics.cc, mappers.cc,
oct-map.cc, octave.cc, ov-base.cc, ov-bool-mat.cc, ov-cell.cc,
ov-fcn-handle.cc, ov-fcn-inline.cc, ov-flt-re-mat.cc, ov-int16.cc, ov-int32.cc,
ov-int64.cc, ov-int8.cc, ov-null-mat.cc, ov-oncleanup.cc, ov-range.cc,
ov-re-mat.cc, ov-struct.cc, ov-typeinfo.cc, ov-uint16.cc, ov-uint32.cc,
ov-uint64.cc, ov-uint8.cc, ov.cc, pr-output.cc, pt-binop.cc, pt-eval.cc,
pt-idx.cc, pt-mat.cc, sighandlers.cc, strfns.cc, symtab.cc, syscalls.cc,
sysdep.cc, toplev.cc, utils.cc, variables.cc: Update %!tests in src/ directory
with Octave coding conventions.
| author | Rik <octave@nomad.inbox5.com> |
|---|---|
| date | Sun, 04 Mar 2012 12:21:10 -0800 |
| parents | 72c96de7a403 |
| children |
| rev | line source |
|---|---|
| 2376 | 1 /* |
| 2 | |
|
14138
72c96de7a403
maint: update copyright notices for 2012
John W. Eaton <jwe@octave.org>
parents:
14013
diff
changeset
|
3 Copyright (C) 1996-2012 John W. Eaton |
| 2376 | 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 the | |
| 7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
| 10 option) any later version. | |
| 2376 | 11 |
| 12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 7016 | 18 along with Octave; see the file COPYING. If not, see |
| 19 <http://www.gnu.org/licenses/>. | |
| 2376 | 20 |
| 21 */ | |
| 22 | |
| 23 #ifdef HAVE_CONFIG_H | |
| 24 #include <config.h> | |
| 25 #endif | |
| 26 | |
|
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
27 #include "Array.h" |
|
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
28 #include "singleton-cleanup.h" |
| 2376 | 29 |
| 30 #include "defun.h" | |
| 31 #include "error.h" | |
|
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
32 #include "ov-typeinfo.h" |
| 2376 | 33 |
| 2479 | 34 const int |
| 35 octave_value_typeinfo::init_tab_sz (16); | |
| 36 | |
| 37 octave_value_typeinfo * | |
| 38 octave_value_typeinfo::instance (0); | |
| 2376 | 39 |
| 2926 | 40 bool |
| 41 octave_value_typeinfo::instance_ok (void) | |
| 42 { | |
| 43 bool retval = true; | |
|
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
44 |
| 2926 | 45 if (! instance) |
|
13983
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
46 { |
|
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
47 instance = new octave_value_typeinfo (); |
|
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
48 |
|
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
49 if (instance) |
|
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
50 singleton_cleanup_list::add (cleanup_instance); |
|
7dd7cccf0757
clean up memory allocated for singletons before exit
John W. Eaton <jwe@octave.org>
parents:
13095
diff
changeset
|
51 } |
| 2926 | 52 |
| 53 if (! instance) | |
| 54 { | |
| 55 ::error ("unable to create value type info object!"); | |
| 56 | |
| 57 retval = false; | |
| 58 } | |
| 59 | |
| 60 return retval; | |
| 61 } | |
| 62 | |
| 2376 | 63 int |
| 4612 | 64 octave_value_typeinfo::register_type (const std::string& t_name, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
65 const std::string& c_name, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
66 const octave_value& val) |
| 2376 | 67 { |
| 2926 | 68 return (instance_ok ()) |
| 4640 | 69 ? instance->do_register_type (t_name, c_name, val) : -1; |
| 2376 | 70 } |
| 71 | |
| 72 bool | |
| 7336 | 73 octave_value_typeinfo::register_unary_class_op (octave_value::unary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
74 octave_value_typeinfo::unary_class_op_fcn f) |
| 7336 | 75 { |
| 76 return (instance_ok ()) | |
| 77 ? instance->do_register_unary_class_op (op, f) : false; | |
| 78 } | |
| 79 | |
| 80 bool | |
| 3203 | 81 octave_value_typeinfo::register_unary_op (octave_value::unary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
82 int t, octave_value_typeinfo::unary_op_fcn f) |
| 3203 | 83 { |
| 84 return (instance_ok ()) | |
| 85 ? instance->do_register_unary_op (op, t, f) : false; | |
| 86 } | |
| 87 | |
| 88 bool | |
| 89 octave_value_typeinfo::register_non_const_unary_op (octave_value::unary_op op, | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
90 int t, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
91 octave_value_typeinfo::non_const_unary_op_fcn f) |
| 3203 | 92 { |
| 93 return (instance_ok ()) | |
| 94 ? instance->do_register_non_const_unary_op (op, t, f) : false; | |
| 95 } | |
| 96 | |
| 97 bool | |
| 7336 | 98 octave_value_typeinfo::register_binary_class_op (octave_value::binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
99 octave_value_typeinfo::binary_class_op_fcn f) |
| 7336 | 100 { |
| 101 return (instance_ok ()) | |
| 102 ? instance->do_register_binary_class_op (op, f) : false; | |
| 103 } | |
| 104 | |
| 105 bool | |
| 2376 | 106 octave_value_typeinfo::register_binary_op (octave_value::binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
107 int t1, int t2, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
108 octave_value_typeinfo::binary_op_fcn f) |
| 2376 | 109 { |
| 2926 | 110 return (instance_ok ()) |
| 111 ? instance->do_register_binary_op (op, t1, t2, f) : false; | |
| 2376 | 112 } |
| 113 | |
| 114 bool | |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
115 octave_value_typeinfo::register_binary_class_op (octave_value::compound_binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
116 octave_value_typeinfo::binary_class_op_fcn f) |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
117 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
118 return (instance_ok ()) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
119 ? instance->do_register_binary_class_op (op, f) : false; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
120 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
121 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
122 bool |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
123 octave_value_typeinfo::register_binary_op (octave_value::compound_binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
124 int t1, int t2, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
125 octave_value_typeinfo::binary_op_fcn f) |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
126 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
127 return (instance_ok ()) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
128 ? instance->do_register_binary_op (op, t1, t2, f) : false; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
129 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
130 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
131 bool |
| 5759 | 132 octave_value_typeinfo::register_cat_op (int t1, int t2, octave_value_typeinfo::cat_op_fcn f) |
| 4915 | 133 { |
| 134 return (instance_ok ()) | |
| 135 ? instance->do_register_cat_op (t1, t2, f) : false; | |
| 136 } | |
| 137 | |
| 138 bool | |
| 2882 | 139 octave_value_typeinfo::register_assign_op (octave_value::assign_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
140 int t_lhs, int t_rhs, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
141 octave_value_typeinfo::assign_op_fcn f) |
| 2376 | 142 { |
| 2926 | 143 return (instance_ok ()) |
| 144 ? instance->do_register_assign_op (op, t_lhs, t_rhs, f) : -1; | |
| 2376 | 145 } |
| 146 | |
| 147 bool | |
| 3196 | 148 octave_value_typeinfo::register_assignany_op (octave_value::assign_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
149 int t_lhs, octave_value_typeinfo::assignany_op_fcn f) |
| 3196 | 150 { |
| 151 return (instance_ok ()) | |
| 152 ? instance->do_register_assignany_op (op, t_lhs, f) : -1; | |
| 153 } | |
| 154 | |
| 155 bool | |
| 2376 | 156 octave_value_typeinfo::register_pref_assign_conv (int t_lhs, int t_rhs, |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
157 int t_result) |
| 2376 | 158 { |
| 2926 | 159 return (instance_ok ()) |
| 160 ? instance->do_register_pref_assign_conv (t_lhs, t_rhs, t_result) : false; | |
| 2376 | 161 } |
| 162 | |
| 163 bool | |
| 4901 | 164 octave_value_typeinfo::register_type_conv_op (int t, int t_result, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
165 octave_base_value::type_conv_fcn f) |
| 4901 | 166 { |
| 167 return (instance_ok ()) | |
| 168 ? instance->do_register_type_conv_op (t, t_result, f) : false; | |
| 169 } | |
| 170 | |
| 171 bool | |
| 2376 | 172 octave_value_typeinfo::register_widening_op (int t, int t_result, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
173 octave_base_value::type_conv_fcn f) |
| 2376 | 174 { |
| 2926 | 175 return (instance_ok ()) |
| 176 ? instance->do_register_widening_op (t, t_result, f) : false; | |
| 2376 | 177 } |
| 178 | |
| 5775 | 179 // FIXME -- we should also store all class names and provide a |
| 4687 | 180 // way to list them (calling class with nargin == 0?). |
| 181 | |
| 2376 | 182 int |
| 4612 | 183 octave_value_typeinfo::do_register_type (const std::string& t_name, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
184 const std::string& /* c_name */, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
185 const octave_value& val) |
| 2376 | 186 { |
| 187 int i = 0; | |
| 188 | |
| 189 for (i = 0; i < num_types; i++) | |
| 4612 | 190 if (t_name == types (i)) |
| 2376 | 191 return i; |
| 192 | |
| 193 int len = types.length (); | |
| 194 | |
| 195 if (i == len) | |
| 196 { | |
| 197 len *= 2; | |
| 198 | |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
199 types.resize (dim_vector (len, 1), std::string ()); |
| 2376 | 200 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
201 vals.resize (dim_vector (len, 1), octave_value ()); |
| 4640 | 202 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
203 unary_ops.resize (dim_vector (octave_value::num_unary_ops, len), 0); |
| 3203 | 204 |
| 205 non_const_unary_ops.resize | |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
206 (dim_vector (octave_value::num_unary_ops, len), 0); |
| 3203 | 207 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
208 binary_ops.resize |
|
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
209 (dim_vector (octave_value::num_binary_ops, len, len), 0); |
| 2376 | 210 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
211 compound_binary_ops.resize |
|
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
212 (dim_vector (octave_value::num_compound_binary_ops, len, len), 0); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
213 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
214 cat_ops.resize (dim_vector (len, len), 0); |
| 4915 | 215 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
216 assign_ops.resize |
|
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
217 (dim_vector (octave_value::num_assign_ops, len, len), 0); |
| 2376 | 218 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
219 assignany_ops.resize |
|
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
220 (dim_vector (octave_value::num_assign_ops, len), 0); |
| 3196 | 221 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
222 pref_assign_conv.resize (dim_vector (len, len), -1); |
| 2376 | 223 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
224 type_conv_ops.resize (dim_vector (len, len), 0); |
| 4901 | 225 |
|
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
226 widening_ops.resize (dim_vector (len, len), 0); |
| 2376 | 227 } |
| 228 | |
| 4612 | 229 types (i) = t_name; |
| 2376 | 230 |
| 4640 | 231 vals (i) = val; |
| 232 | |
| 2376 | 233 num_types++; |
| 234 | |
| 235 return i; | |
| 236 } | |
| 237 | |
| 238 bool | |
| 7336 | 239 octave_value_typeinfo::do_register_unary_class_op (octave_value::unary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
240 octave_value_typeinfo::unary_class_op_fcn f) |
| 7336 | 241 { |
| 242 if (lookup_unary_class_op (op)) | |
| 243 { | |
| 244 std::string op_name = octave_value::unary_op_as_string (op); | |
| 245 | |
| 246 warning ("duplicate unary operator `%s' for class dispatch", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
247 op_name.c_str ()); |
| 7336 | 248 } |
| 249 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
250 unary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f); |
| 7336 | 251 |
| 252 return false; | |
| 253 } | |
| 254 | |
| 255 bool | |
| 3203 | 256 octave_value_typeinfo::do_register_unary_op (octave_value::unary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
257 int t, octave_value_typeinfo::unary_op_fcn f) |
| 3203 | 258 { |
| 4508 | 259 if (lookup_unary_op (op, t)) |
| 260 { | |
| 261 std::string op_name = octave_value::unary_op_as_string (op); | |
| 262 std::string type_name = types(t); | |
| 263 | |
| 264 warning ("duplicate unary operator `%s' for type `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
265 op_name.c_str (), type_name.c_str ()); |
| 4508 | 266 } |
| 267 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
268 unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f); |
| 3203 | 269 |
| 270 return false; | |
| 271 } | |
| 272 | |
| 273 bool | |
| 274 octave_value_typeinfo::do_register_non_const_unary_op | |
| 5759 | 275 (octave_value::unary_op op, int t, octave_value_typeinfo::non_const_unary_op_fcn f) |
| 3203 | 276 { |
| 4508 | 277 if (lookup_non_const_unary_op (op, t)) |
| 278 { | |
| 279 std::string op_name = octave_value::unary_op_as_string (op); | |
| 280 std::string type_name = types(t); | |
| 281 | |
| 282 warning ("duplicate unary operator `%s' for type `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
283 op_name.c_str (), type_name.c_str ()); |
| 4508 | 284 } |
| 285 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
286 non_const_unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f); |
| 3203 | 287 |
| 288 return false; | |
| 289 } | |
| 290 | |
| 291 bool | |
| 7336 | 292 octave_value_typeinfo::do_register_binary_class_op (octave_value::binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
293 octave_value_typeinfo::binary_class_op_fcn f) |
| 7336 | 294 { |
| 295 if (lookup_binary_class_op (op)) | |
| 296 { | |
| 297 std::string op_name = octave_value::binary_op_as_string (op); | |
| 298 | |
| 299 warning ("duplicate binary operator `%s' for class dispatch", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
300 op_name.c_str ()); |
| 7336 | 301 } |
| 302 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
303 binary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f); |
| 7336 | 304 |
| 305 return false; | |
| 306 } | |
| 307 | |
| 308 bool | |
| 2376 | 309 octave_value_typeinfo::do_register_binary_op (octave_value::binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
310 int t1, int t2, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
311 octave_value_typeinfo::binary_op_fcn f) |
| 2376 | 312 { |
| 4508 | 313 if (lookup_binary_op (op, t1, t2)) |
| 314 { | |
| 315 std::string op_name = octave_value::binary_op_as_string (op); | |
| 316 std::string t1_name = types(t1); | |
| 317 std::string t2_name = types(t2); | |
| 318 | |
| 319 warning ("duplicate binary operator `%s' for types `%s' and `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
320 op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); |
| 4508 | 321 } |
| 322 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
323 binary_ops.checkelem (static_cast<int> (op), t1, t2) = reinterpret_cast<void *> (f); |
| 2376 | 324 |
| 325 return false; | |
| 326 } | |
| 327 | |
| 328 bool | |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
329 octave_value_typeinfo::do_register_binary_class_op (octave_value::compound_binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
330 octave_value_typeinfo::binary_class_op_fcn f) |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
331 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
332 if (lookup_binary_class_op (op)) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
333 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
334 std::string op_name = octave_value::binary_op_fcn_name (op); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
335 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
336 warning ("duplicate compound binary operator `%s' for class dispatch", |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
337 op_name.c_str ()); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
338 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
339 |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
340 compound_binary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
341 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
342 return false; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
343 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
344 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
345 bool |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
346 octave_value_typeinfo::do_register_binary_op (octave_value::compound_binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
347 int t1, int t2, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
348 octave_value_typeinfo::binary_op_fcn f) |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
349 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
350 if (lookup_binary_op (op, t1, t2)) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
351 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
352 std::string op_name = octave_value::binary_op_fcn_name (op); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
353 std::string t1_name = types(t1); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
354 std::string t2_name = types(t2); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
355 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
356 warning ("duplicate compound binary operator `%s' for types `%s' and `%s'", |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
357 op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
358 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
359 |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
360 compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) = reinterpret_cast<void *> (f); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
361 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
362 return false; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
363 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
364 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
365 bool |
| 5759 | 366 octave_value_typeinfo::do_register_cat_op (int t1, int t2, octave_value_typeinfo::cat_op_fcn f) |
| 4915 | 367 { |
| 368 if (lookup_cat_op (t1, t2)) | |
| 369 { | |
| 370 std::string t1_name = types(t1); | |
| 371 std::string t2_name = types(t2); | |
| 372 | |
| 373 warning ("duplicate concatenation operator for types `%s' and `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
374 t1_name.c_str (), t1_name.c_str ()); |
| 4915 | 375 } |
| 376 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
377 cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f); |
| 4915 | 378 |
| 379 return false; | |
| 380 } | |
| 381 | |
| 382 bool | |
| 2882 | 383 octave_value_typeinfo::do_register_assign_op (octave_value::assign_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
384 int t_lhs, int t_rhs, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
385 octave_value_typeinfo::assign_op_fcn f) |
| 2376 | 386 { |
| 4508 | 387 if (lookup_assign_op (op, t_lhs, t_rhs)) |
| 388 { | |
| 389 std::string op_name = octave_value::assign_op_as_string (op); | |
| 390 std::string t_lhs_name = types(t_lhs); | |
| 391 std::string t_rhs_name = types(t_rhs); | |
| 392 | |
| 393 warning ("duplicate assignment operator `%s' for types `%s' and `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
394 op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ()); |
| 4508 | 395 } |
| 396 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
397 assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) = reinterpret_cast<void *> (f); |
| 2376 | 398 |
| 399 return false; | |
| 400 } | |
| 401 | |
| 402 bool | |
| 3196 | 403 octave_value_typeinfo::do_register_assignany_op (octave_value::assign_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
404 int t_lhs, octave_value_typeinfo::assignany_op_fcn f) |
| 3196 | 405 { |
| 4508 | 406 if (lookup_assignany_op (op, t_lhs)) |
| 407 { | |
| 408 std::string op_name = octave_value::assign_op_as_string (op); | |
| 409 std::string t_lhs_name = types(t_lhs); | |
| 410 | |
| 411 warning ("duplicate assignment operator `%s' for types `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
412 op_name.c_str (), t_lhs_name.c_str ()); |
| 4508 | 413 } |
| 414 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
415 assignany_ops.checkelem (static_cast<int> (op), t_lhs) = reinterpret_cast<void *> (f); |
| 3196 | 416 |
| 417 return false; | |
| 418 } | |
| 419 | |
| 420 bool | |
| 2376 | 421 octave_value_typeinfo::do_register_pref_assign_conv (int t_lhs, int t_rhs, |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
422 int t_result) |
| 2376 | 423 { |
| 4508 | 424 if (lookup_pref_assign_conv (t_lhs, t_rhs) >= 0) |
| 425 { | |
| 426 std::string t_lhs_name = types(t_lhs); | |
| 427 std::string t_rhs_name = types(t_rhs); | |
| 428 | |
| 429 warning ("overriding assignment conversion for types `%s' and `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
430 t_lhs_name.c_str (), t_rhs_name.c_str ()); |
| 4508 | 431 } |
| 432 | |
| 2376 | 433 pref_assign_conv.checkelem (t_lhs, t_rhs) = t_result; |
| 434 | |
| 435 return false; | |
| 436 } | |
| 437 | |
| 438 bool | |
| 4901 | 439 octave_value_typeinfo::do_register_type_conv_op |
| 5759 | 440 (int t, int t_result, octave_base_value::type_conv_fcn f) |
| 4901 | 441 { |
| 442 if (lookup_type_conv_op (t, t_result)) | |
| 443 { | |
| 444 std::string t_name = types(t); | |
| 445 std::string t_result_name = types(t_result); | |
| 446 | |
| 447 warning ("overriding type conversion op for `%s' to `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
448 t_name.c_str (), t_result_name.c_str ()); |
| 4901 | 449 } |
| 450 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
451 type_conv_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f); |
| 4901 | 452 |
| 453 return false; | |
| 454 } | |
| 455 | |
| 456 bool | |
| 2376 | 457 octave_value_typeinfo::do_register_widening_op |
| 5759 | 458 (int t, int t_result, octave_base_value::type_conv_fcn f) |
| 2376 | 459 { |
| 4508 | 460 if (lookup_widening_op (t, t_result)) |
| 461 { | |
| 462 std::string t_name = types(t); | |
| 463 std::string t_result_name = types(t_result); | |
| 464 | |
| 465 warning ("overriding widening op for `%s' to `%s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
466 t_name.c_str (), t_result_name.c_str ()); |
| 4508 | 467 } |
| 468 | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
469 widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f); |
| 2376 | 470 |
| 471 return false; | |
| 472 } | |
| 473 | |
| 4640 | 474 octave_value |
| 475 octave_value_typeinfo::do_lookup_type (const std::string& nm) | |
| 476 { | |
| 477 octave_value retval; | |
| 478 | |
| 479 for (int i = 0; i < num_types; i++) | |
| 480 { | |
| 481 if (nm == types(i)) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
482 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
483 retval = vals(i); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
484 retval.make_unique (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
485 break; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
486 } |
| 4640 | 487 } |
| 488 | |
| 489 return retval; | |
| 490 } | |
| 491 | |
| 7336 | 492 octave_value_typeinfo::unary_class_op_fcn |
| 493 octave_value_typeinfo::do_lookup_unary_class_op (octave_value::unary_op op) | |
| 494 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
495 void *f = unary_class_ops.checkelem (static_cast<int> (op)); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
496 return reinterpret_cast<octave_value_typeinfo::unary_class_op_fcn> (f); |
| 7336 | 497 } |
| 498 | |
| 5759 | 499 octave_value_typeinfo::unary_op_fcn |
| 3203 | 500 octave_value_typeinfo::do_lookup_unary_op (octave_value::unary_op op, int t) |
| 501 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
502 void *f = unary_ops.checkelem (static_cast<int> (op), t); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
503 return reinterpret_cast<octave_value_typeinfo::unary_op_fcn> (f); |
| 3203 | 504 } |
| 505 | |
| 5759 | 506 octave_value_typeinfo::non_const_unary_op_fcn |
| 3203 | 507 octave_value_typeinfo::do_lookup_non_const_unary_op |
| 508 (octave_value::unary_op op, int t) | |
| 509 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
510 void *f = non_const_unary_ops.checkelem (static_cast<int> (op), t); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
511 return reinterpret_cast<octave_value_typeinfo::non_const_unary_op_fcn> (f); |
| 3203 | 512 } |
| 513 | |
| 7336 | 514 octave_value_typeinfo::binary_class_op_fcn |
| 515 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::binary_op op) | |
| 516 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
517 void *f = binary_class_ops.checkelem (static_cast<int> (op)); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
518 return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f); |
| 7336 | 519 } |
| 520 | |
| 5759 | 521 octave_value_typeinfo::binary_op_fcn |
| 2376 | 522 octave_value_typeinfo::do_lookup_binary_op (octave_value::binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
523 int t1, int t2) |
| 2376 | 524 { |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
525 void *f = binary_ops.checkelem (static_cast<int> (op), t1, t2); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
526 return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f); |
| 2376 | 527 } |
| 528 | |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
529 octave_value_typeinfo::binary_class_op_fcn |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
530 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::compound_binary_op op) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
531 { |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
532 void *f = compound_binary_class_ops.checkelem (static_cast<int> (op)); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
533 return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
534 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
535 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
536 octave_value_typeinfo::binary_op_fcn |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
537 octave_value_typeinfo::do_lookup_binary_op (octave_value::compound_binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
538 int t1, int t2) |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
539 { |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
540 void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
541 return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f); |
|
7800
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
542 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7433
diff
changeset
|
543 |
| 5759 | 544 octave_value_typeinfo::cat_op_fcn |
| 4915 | 545 octave_value_typeinfo::do_lookup_cat_op (int t1, int t2) |
| 546 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
547 void *f = cat_ops.checkelem (t1, t2); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
548 return reinterpret_cast<octave_value_typeinfo::cat_op_fcn> (f); |
| 4915 | 549 } |
| 550 | |
| 5759 | 551 octave_value_typeinfo::assign_op_fcn |
| 2882 | 552 octave_value_typeinfo::do_lookup_assign_op (octave_value::assign_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
553 int t_lhs, int t_rhs) |
| 2376 | 554 { |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
555 void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
556 return reinterpret_cast<octave_value_typeinfo::assign_op_fcn> (f); |
| 2376 | 557 } |
| 558 | |
| 5759 | 559 octave_value_typeinfo::assignany_op_fcn |
| 3196 | 560 octave_value_typeinfo::do_lookup_assignany_op (octave_value::assign_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
561 int t_lhs) |
| 3196 | 562 { |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
563 void *f = assignany_ops.checkelem (static_cast<int> (op), t_lhs); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
564 return reinterpret_cast<octave_value_typeinfo::assignany_op_fcn> (f); |
| 3196 | 565 } |
| 566 | |
| 2376 | 567 int |
| 568 octave_value_typeinfo::do_lookup_pref_assign_conv (int t_lhs, int t_rhs) | |
| 569 { | |
| 570 return pref_assign_conv.checkelem (t_lhs, t_rhs); | |
| 571 } | |
| 572 | |
| 5759 | 573 octave_base_value::type_conv_fcn |
| 4901 | 574 octave_value_typeinfo::do_lookup_type_conv_op (int t, int t_result) |
| 575 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
576 void *f = type_conv_ops.checkelem (t, t_result); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
577 return reinterpret_cast<octave_base_value::type_conv_fcn> (f); |
| 4901 | 578 } |
| 579 | |
| 5759 | 580 octave_base_value::type_conv_fcn |
| 2376 | 581 octave_value_typeinfo::do_lookup_widening_op (int t, int t_result) |
| 582 { | |
|
9223
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
583 void *f = widening_ops.checkelem (t, t_result); |
|
902a4597dce8
use Array<void *> in ov-typeinfo.h
Jaroslav Hajek <highegg@gmail.com>
parents:
9219
diff
changeset
|
584 return reinterpret_cast<octave_base_value::type_conv_fcn> (f); |
| 2376 | 585 } |
| 586 | |
| 587 string_vector | |
| 588 octave_value_typeinfo::do_installed_type_names (void) | |
| 589 { | |
| 590 string_vector retval (num_types); | |
| 591 | |
|
11438
9e8497537319
typeinfo: return cellstr, not char array
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
592 for (int i = 0; i < num_types; i++) |
|
9e8497537319
typeinfo: return cellstr, not char array
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
593 retval(i) = types(i); |
| 2376 | 594 |
| 595 return retval; | |
| 596 } | |
| 597 | |
| 2457 | 598 DEFUN (typeinfo, args, , |
| 3445 | 599 "-*- texinfo -*-\n\ |
|
12546
39ca02387a32
Improve docstrings for a number of functions.
Rik <octave@nomad.inbox5.com>
parents:
11586
diff
changeset
|
600 @deftypefn {Built-in Function} {} typeinfo ()\n\ |
|
39ca02387a32
Improve docstrings for a number of functions.
Rik <octave@nomad.inbox5.com>
parents:
11586
diff
changeset
|
601 @deftypefnx {Built-in Function} {} typeinfo (@var{expr})\n\ |
| 2822 | 602 \n\ |
| 3445 | 603 Return the type of the expression @var{expr}, as a string. If\n\ |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
604 @var{expr} is omitted, return an cell array of strings containing all the\n\ |
| 3445 | 605 currently installed data types.\n\ |
| 606 @end deftypefn") | |
| 2376 | 607 { |
| 608 octave_value retval; | |
| 609 | |
| 610 int nargin = args.length (); | |
| 611 | |
| 612 if (nargin == 0) | |
|
11438
9e8497537319
typeinfo: return cellstr, not char array
John W. Eaton <jwe@octave.org>
parents:
10352
diff
changeset
|
613 retval = Cell (octave_value_typeinfo::installed_type_names ()); |
| 2822 | 614 else if (nargin == 1) |
| 615 retval = args(0).type_name (); | |
| 2376 | 616 else |
| 5823 | 617 print_usage (); |
| 2376 | 618 |
| 619 return retval; | |
| 620 } | |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
621 |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
622 /* |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
623 %!assert (iscellstr (typeinfo ())) |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
624 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
625 %!assert (typeinfo ({"cell"}), "cell") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
626 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
627 %!assert (typeinfo (1), "scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
628 %!assert (typeinfo (double (1)), "scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
629 %!assert (typeinfo (i), "complex scalar") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
630 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
631 %!assert (typeinfo ([1, 2]), "matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
632 %!assert (typeinfo (double ([1, 2])), "matrix") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
633 %!assert (typeinfo (diag ([1, 2])), "diagonal matrix") |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
634 %!assert (typeinfo ([i, 2]), "complex matrix") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
635 %!assert (typeinfo (diag ([i, 2])), "complex diagonal matrix") |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
636 |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
637 %!assert (typeinfo (1:2), "range") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
638 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
639 %!assert (typeinfo (false), "bool") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
640 %!assert (typeinfo ([true, false]), "bool matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
641 |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
642 %!assert (typeinfo ("string"), "string") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
643 %!assert (typeinfo ('string'), "sq_string") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
644 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
645 %!assert (typeinfo (int8 (1)), "int8 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
646 %!assert (typeinfo (int16 (1)), "int16 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
647 %!assert (typeinfo (int32 (1)), "int32 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
648 %!assert (typeinfo (int64 (1)), "int64 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
649 %!assert (typeinfo (uint8 (1)), "uint8 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
650 %!assert (typeinfo (uint16 (1)), "uint16 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
651 %!assert (typeinfo (uint32 (1)), "uint32 scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
652 %!assert (typeinfo (uint64 (1)), "uint64 scalar") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
653 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
654 %!assert (typeinfo (int8 ([1,2])), "int8 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
655 %!assert (typeinfo (int16 ([1,2])), "int16 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
656 %!assert (typeinfo (int32 ([1,2])), "int32 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
657 %!assert (typeinfo (int64 ([1,2])), "int64 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
658 %!assert (typeinfo (uint8 ([1,2])), "uint8 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
659 %!assert (typeinfo (uint16 ([1,2])), "uint16 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
660 %!assert (typeinfo (uint32 ([1,2])), "uint32 matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
661 %!assert (typeinfo (uint64 ([1,2])), "uint64 matrix") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
662 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
663 %!assert (typeinfo (sparse ([true, false])), "sparse bool matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
664 %!assert (typeinfo (logical (sparse (i * eye (10)))), "sparse bool matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
665 %!assert (typeinfo (sparse ([1,2])), "sparse matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
666 %!assert (typeinfo (sparse (eye (10))), "sparse matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
667 %!assert (typeinfo (sparse ([i,2])), "sparse complex matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
668 %!assert (typeinfo (sparse (i * eye (10))), "sparse complex matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
669 |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
670 %!test |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
671 %! s(2).a = 1; |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
672 %! assert (typeinfo (s), "struct"); |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
673 |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
674 %!test |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
675 %! s.a = 1; |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
676 %! assert (typeinfo (s), "scalar struct"); |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
677 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
678 ## FIXME: This doesn't work as a test for comma-separated list |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
679 %!#test |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
680 %! clist = {1, 2, 3}; |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
681 %! assert (typeinfo (clist{:}), "cs-list"); |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
682 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
683 %!assert (typeinfo (@sin), "function handle") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
684 %!assert (typeinfo (@(x) x), "function handle") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
685 |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
686 %!assert (typeinfo (inline ("x^2")), "inline function") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
687 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
688 %!assert (typeinfo (single (1)), "float scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
689 %!assert (typeinfo (single (i)), "float complex scalar") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
690 %!assert (typeinfo (single ([1, 2])), "float matrix") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
691 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
692 %!assert (typeinfo (single (diag ([1, 2]))), "float diagonal matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
693 %!assert (typeinfo (diag (single ([1, 2]))), "float diagonal matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
694 %!assert (typeinfo (single (diag ([i, 2]))), "float complex diagonal matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
695 %!assert (typeinfo (diag (single ([i, 2]))), "float complex diagonal matrix") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
696 |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
697 %!assert (typeinfo (eye(3)(:,[1 3 2])), "permutation matrix") |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
698 %!test |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
699 %! [l, u, p] = lu (rand (3)); |
|
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
700 %! assert (typeinfo (p), "permutation matrix"); |
|
14429
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
701 |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
702 %!assert (typeinfo ([]), "null_matrix") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
703 %!assert (typeinfo (""), "null_string") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
704 %!assert (typeinfo (''), "null_sq_string") |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
705 |
|
eff4a5933e28
Update %!tests in src/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
706 %!error typeinfo ("foo", 1) |
|
13095
32fdd834c09a
tests for typeinfo function
John W. Eaton <jwe@octave.org>
parents:
12546
diff
changeset
|
707 */ |