GNU Octave  3.8.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
op-fcs-fcs.cc
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 1996-2013 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 the
9 Free Software Foundation; either version 3 of the License, or (at your
10 option) any later version.
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
18 along with Octave; see the file COPYING. If not, see
19 <http://www.gnu.org/licenses/>.
20 
21 */
22 
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26 
27 #include "gripes.h"
28 #include "oct-obj.h"
29 #include "ov.h"
30 #include "ov-complex.h"
31 #include "ov-flt-complex.h"
32 #include "ov-flt-cx-mat.h"
33 #include "ov-typeinfo.h"
34 #include "ov-null-mat.h"
35 #include "ops.h"
36 #include "xdiv.h"
37 #include "xpow.h"
38 
39 // unary complex scalar ops.
40 
41 DEFUNOP (not, float_complex)
42 {
43  CAST_UNOP_ARG (const octave_float_complex&);
44  FloatComplex x = v.float_complex_value ();
45  if (xisnan (x))
46  gripe_nan_to_logical_conversion ();
47  return octave_value (x == 0.0f);
48 }
49 
50 DEFUNOP_OP (uplus, float_complex, /* no-op */)
51 DEFUNOP_OP (uminus, float_complex, -)
52 DEFUNOP_OP (transpose, float_complex, /* no-op */)
53 
54 DEFUNOP (hermitian, float_complex)
55 {
56  CAST_UNOP_ARG (const octave_float_complex&);
57 
58  return octave_value (conj (v.float_complex_value ()));
59 }
60 
61 DEFNCUNOP_METHOD (incr, float_complex, increment)
62 DEFNCUNOP_METHOD (decr, float_complex, decrement)
63 
64 // complex scalar by complex scalar ops.
65 
66 DEFBINOP_OP (add, float_complex, float_complex, +)
67 DEFBINOP_OP (sub, float_complex, float_complex, -)
68 DEFBINOP_OP (mul, float_complex, float_complex, *)
69 
70 DEFBINOP (div, float_complex, float_complex)
71 {
72  CAST_BINOP_ARGS (const octave_float_complex&, const octave_float_complex&);
73 
74  FloatComplex d = v2.float_complex_value ();
75 
76  if (d == static_cast<float>(0.0))
77  gripe_divide_by_zero ();
78 
79  return octave_value (v1.float_complex_value () / d);
80 }
81 
82 DEFBINOP_FN (pow, float_complex, float_complex, xpow)
83 
84 DEFBINOP (ldiv, float_complex, float_complex)
85 {
86  CAST_BINOP_ARGS (const octave_float_complex&, const octave_float_complex&);
87 
88  FloatComplex d = v1.float_complex_value ();
89 
90  if (d == static_cast<float>(0.0))
91  gripe_divide_by_zero ();
92 
93  return octave_value (v2.float_complex_value () / d);
94 }
95 
96 DEFCMPLXCMPOP_OP (lt, float_complex, float_complex, <)
97 DEFCMPLXCMPOP_OP (le, float_complex, float_complex, <=)
98 DEFCMPLXCMPOP_OP (eq, float_complex, float_complex, ==)
99 DEFCMPLXCMPOP_OP (ge, float_complex, float_complex, >=)
100 DEFCMPLXCMPOP_OP (gt, float_complex, float_complex, >)
101 DEFCMPLXCMPOP_OP (ne, float_complex, float_complex, !=)
102 
103 DEFBINOP_OP (el_mul, float_complex, float_complex, *)
104 
105 DEFBINOP (el_div, float_complex, float_complex)
106 {
107  CAST_BINOP_ARGS (const octave_float_complex&, const octave_float_complex&);
108 
109  FloatComplex d = v2.float_complex_value ();
110 
111  if (d == static_cast<float>(0.0))
112  gripe_divide_by_zero ();
113 
114  return octave_value (v1.float_complex_value () / d);
115 }
116 
117 DEFBINOP_FN (el_pow, float_complex, float_complex, xpow)
118 
119 DEFBINOP (el_ldiv, float_complex, float_complex)
120 {
121  CAST_BINOP_ARGS (const octave_float_complex&, const octave_float_complex&);
122 
123  FloatComplex d = v1.float_complex_value ();
124 
125  if (d == static_cast<float>(0.0))
126  gripe_divide_by_zero ();
127 
128  return octave_value (v2.float_complex_value () / d);
129 }
130 
131 DEFBINOP (el_and, float_complex, float_complex)
132 {
133  CAST_BINOP_ARGS (const octave_float_complex&, const octave_float_complex&);
134 
135  return (v1.float_complex_value () != static_cast<float>(0.0) &&
136  v2.float_complex_value () != static_cast<float>(0.0));
137 }
138 
139 DEFBINOP (el_or, float_complex, float_complex)
140 {
141  CAST_BINOP_ARGS (const octave_float_complex&, const octave_float_complex&);
142 
143  return (v1.float_complex_value () != static_cast<float>(0.0) ||
144  v2.float_complex_value () != static_cast<float>(0.0));
145 }
146 
147 DEFNDCATOP_FN (fcs_fcs, float_complex, float_complex, float_complex_array,
148  float_complex_array, concat)
149 
150 DEFNDCATOP_FN (cs_fcs, complex, float_complex, float_complex_array,
151  float_complex_array, concat)
152 
153 DEFNDCATOP_FN (fcs_cs, float_complex, complex, float_complex_array,
154  float_complex_array, concat)
155 
156 CONVDECL (float_complex_to_complex)
157 {
158  CAST_CONV_ARG (const octave_float_complex&);
159 
160  return new octave_complex_matrix
161  (ComplexMatrix (1, 1,
162  static_cast<Complex>(v.float_complex_value ())));
163 }
164 
165 void
166 install_fcs_fcs_ops (void)
167 {
168  INSTALL_UNOP (op_not, octave_float_complex, not);
169  INSTALL_UNOP (op_uplus, octave_float_complex, uplus);
170  INSTALL_UNOP (op_uminus, octave_float_complex, uminus);
171  INSTALL_UNOP (op_transpose, octave_float_complex, transpose);
172  INSTALL_UNOP (op_hermitian, octave_float_complex, hermitian);
173 
174  INSTALL_NCUNOP (op_incr, octave_float_complex, incr);
175  INSTALL_NCUNOP (op_decr, octave_float_complex, decr);
176 
177  INSTALL_BINOP (op_add, octave_float_complex, octave_float_complex, add);
178  INSTALL_BINOP (op_sub, octave_float_complex, octave_float_complex, sub);
179  INSTALL_BINOP (op_mul, octave_float_complex, octave_float_complex, mul);
180  INSTALL_BINOP (op_div, octave_float_complex, octave_float_complex, div);
181  INSTALL_BINOP (op_pow, octave_float_complex, octave_float_complex, pow);
182  INSTALL_BINOP (op_ldiv, octave_float_complex, octave_float_complex, ldiv);
183  INSTALL_BINOP (op_lt, octave_float_complex, octave_float_complex, lt);
184  INSTALL_BINOP (op_le, octave_float_complex, octave_float_complex, le);
185  INSTALL_BINOP (op_eq, octave_float_complex, octave_float_complex, eq);
186  INSTALL_BINOP (op_ge, octave_float_complex, octave_float_complex, ge);
187  INSTALL_BINOP (op_gt, octave_float_complex, octave_float_complex, gt);
188  INSTALL_BINOP (op_ne, octave_float_complex, octave_float_complex, ne);
189  INSTALL_BINOP (op_el_mul, octave_float_complex, octave_float_complex, el_mul);
190  INSTALL_BINOP (op_el_div, octave_float_complex, octave_float_complex, el_div);
191  INSTALL_BINOP (op_el_pow, octave_float_complex, octave_float_complex, el_pow);
192  INSTALL_BINOP (op_el_ldiv, octave_float_complex, octave_float_complex,
193  el_ldiv);
194  INSTALL_BINOP (op_el_and, octave_float_complex, octave_float_complex, el_and);
195  INSTALL_BINOP (op_el_or, octave_float_complex, octave_float_complex, el_or);
196 
197  INSTALL_CATOP (octave_float_complex, octave_float_complex, fcs_fcs);
198  INSTALL_CATOP (octave_complex, octave_float_complex, cs_fcs);
199  INSTALL_CATOP (octave_float_complex, octave_complex, fcs_cs);
200 
201  INSTALL_ASSIGNCONV (octave_float_complex, octave_float_complex,
202  octave_float_complex_matrix);
203 
204  INSTALL_ASSIGNCONV (octave_complex, octave_float_complex,
205  octave_complex_matrix);
206 
207  INSTALL_ASSIGNCONV (octave_float_complex, octave_null_matrix,
208  octave_float_complex_matrix);
209  INSTALL_ASSIGNCONV (octave_float_complex, octave_null_str,
210  octave_float_complex_matrix);
211  INSTALL_ASSIGNCONV (octave_float_complex, octave_null_sq_str,
212  octave_float_complex_matrix);
213 
214  INSTALL_CONVOP (octave_float_complex, octave_complex_matrix,
215  float_complex_to_complex);
216 }
Generated on Mon Dec 30 2013 03:04:35 for GNU Octave by   doxygen 1.8.1.2