GNU Octave 7.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
xpow.h
Go to the documentation of this file.
1////////////////////////////////////////////////////////////////////////
2//
3// Copyright (C) 1993-2022 The Octave Project Developers
4//
5// See the file COPYRIGHT.md in the top-level directory of this
6// distribution or <https://octave.org/copyright/>.
7//
8// This file is part of Octave.
9//
10// Octave is free software: you can redistribute it and/or modify it
11// under the terms of the GNU General Public License as published by
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14//
15// Octave is distributed in the hope that it will be useful, but
16// WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with Octave; see the file COPYING. If not, see
22// <https://www.gnu.org/licenses/>.
23//
24////////////////////////////////////////////////////////////////////////
25
26#if ! defined (octave_xpow_h)
27#define octave_xpow_h 1
28
29#include "octave-config.h"
30
31#include "oct-cmplx.h"
32
33class Matrix;
34class ComplexMatrix;
35class FloatMatrix;
36class FloatComplexMatrix;
37class DiagMatrix;
38class ComplexDiagMatrix;
39class FloatDiagMatrix;
40class FloatComplexDiagMatrix;
41class PermMatrix;
42class NDArray;
43class FloatNDArray;
44class ComplexNDArray;
45class FloatComplexNDArray;
46class octave_value;
47class Range;
48
49OCTAVE_NAMESPACE_BEGIN
50
51extern OCTINTERP_API octave_value xpow (double a, double b);
52extern OCTINTERP_API octave_value xpow (double a, const Matrix& b);
53extern OCTINTERP_API octave_value xpow (double a, const Complex& b);
54extern OCTINTERP_API octave_value xpow (double a, const ComplexMatrix& b);
55
56extern OCTINTERP_API octave_value xpow (const Matrix& a, double b);
57extern OCTINTERP_API octave_value xpow (const Matrix& a, const Complex& b);
58
59extern OCTINTERP_API octave_value xpow (const DiagMatrix& a, double b);
60extern OCTINTERP_API octave_value xpow (const DiagMatrix& a, const Complex& b);
61
62extern OCTINTERP_API octave_value xpow (const PermMatrix& a, double b);
63
64extern OCTINTERP_API octave_value xpow (const Complex& a, double b);
65extern OCTINTERP_API octave_value xpow (const Complex& a, const Matrix& b);
66extern OCTINTERP_API octave_value xpow (const Complex& a, const Complex& b);
67extern OCTINTERP_API octave_value xpow (const Complex& a,
68 const ComplexMatrix& b);
69
70extern OCTINTERP_API octave_value xpow (const ComplexMatrix& a, double b);
71extern OCTINTERP_API octave_value xpow (const ComplexMatrix& a,
72 const Complex& b);
73
74extern OCTINTERP_API octave_value xpow (const ComplexDiagMatrix& a, double b);
75extern OCTINTERP_API octave_value xpow (const ComplexDiagMatrix& a,
76 const Complex& b);
77
78extern OCTINTERP_API octave_value elem_xpow (double a, const Matrix& b);
79extern OCTINTERP_API octave_value elem_xpow (double a, const ComplexMatrix& b);
80extern OCTINTERP_API octave_value elem_xpow (double a, const octave::range<double>& r);
81
82extern OCTINTERP_API octave_value elem_xpow (const Matrix& a, double b);
83extern OCTINTERP_API octave_value elem_xpow (const Matrix& a, const Matrix& b);
84extern OCTINTERP_API octave_value elem_xpow (const Matrix& a, const Complex& b);
85extern OCTINTERP_API octave_value elem_xpow (const Matrix& a,
86 const ComplexMatrix& b);
87
88extern OCTINTERP_API octave_value elem_xpow (const Complex& a, const Matrix& b);
89extern OCTINTERP_API octave_value elem_xpow (const Complex& a,
90 const ComplexMatrix& b);
91extern OCTINTERP_API octave_value elem_xpow (const Complex& a, const octave::range<double>& r);
92
93extern OCTINTERP_API octave_value elem_xpow (const ComplexMatrix& a, double b);
94extern OCTINTERP_API octave_value elem_xpow (const ComplexMatrix& a,
95 const Matrix& b);
96extern OCTINTERP_API octave_value elem_xpow (const ComplexMatrix& a,
97 const Complex& b);
98extern OCTINTERP_API octave_value elem_xpow (const ComplexMatrix& a,
99 const ComplexMatrix& b);
100
101extern OCTINTERP_API octave_value elem_xpow (double a, const NDArray& b);
102extern OCTINTERP_API octave_value elem_xpow (double a, const ComplexNDArray& b);
103
104extern OCTINTERP_API octave_value elem_xpow (const NDArray& a, double b);
105extern OCTINTERP_API octave_value elem_xpow (const NDArray& a,
106 const NDArray& b);
107extern OCTINTERP_API octave_value elem_xpow (const NDArray& a,
108 const Complex& b);
109extern OCTINTERP_API octave_value elem_xpow (const NDArray& a,
110 const ComplexNDArray& b);
111
112extern OCTINTERP_API octave_value elem_xpow (const Complex& a,
113 const NDArray& b);
114extern OCTINTERP_API octave_value elem_xpow (const Complex& a,
115 const ComplexNDArray& b);
116
117extern OCTINTERP_API octave_value elem_xpow (const ComplexNDArray& a,
118 double b);
119extern OCTINTERP_API octave_value elem_xpow (const ComplexNDArray& a,
120 const NDArray& b);
121extern OCTINTERP_API octave_value elem_xpow (const ComplexNDArray& a,
122 const Complex& b);
123extern OCTINTERP_API octave_value elem_xpow (const ComplexNDArray& a,
124 const ComplexNDArray& b);
125
126extern OCTINTERP_API octave_value xpow (float a, float b);
127extern OCTINTERP_API octave_value xpow (float a, const FloatMatrix& b);
128extern OCTINTERP_API octave_value xpow (float a, const FloatComplex& b);
129extern OCTINTERP_API octave_value xpow (float a, const FloatComplexMatrix& b);
130
131extern OCTINTERP_API octave_value xpow (const FloatMatrix& a, float b);
132extern OCTINTERP_API octave_value xpow (const FloatMatrix& a,
133 const FloatComplex& b);
134
135extern OCTINTERP_API octave_value xpow (const FloatDiagMatrix& a, float b);
136extern OCTINTERP_API octave_value xpow (const FloatDiagMatrix& a,
137 const FloatComplex& b);
138
139extern OCTINTERP_API octave_value xpow (const FloatComplex& a, float b);
140extern OCTINTERP_API octave_value xpow (const FloatComplex& a,
141 const FloatMatrix& b);
142extern OCTINTERP_API octave_value xpow (const FloatComplex& a,
143 const FloatComplex& b);
144extern OCTINTERP_API octave_value xpow (const FloatComplex& a,
145 const FloatComplexMatrix& b);
146
147extern OCTINTERP_API octave_value xpow (const FloatComplexMatrix& a, float b);
148extern OCTINTERP_API octave_value xpow (const FloatComplexMatrix& a,
149 const FloatComplex& b);
150
151extern OCTINTERP_API octave_value xpow (const FloatComplexDiagMatrix& a,
152 float b);
153extern OCTINTERP_API octave_value xpow (const FloatComplexDiagMatrix& a,
154 const FloatComplex& b);
155
156extern OCTINTERP_API octave_value elem_xpow (float a, const FloatMatrix& b);
157extern OCTINTERP_API octave_value elem_xpow (float a,
158 const FloatComplexMatrix& b);
159
160extern OCTINTERP_API octave_value elem_xpow (const FloatMatrix& a, float b);
161extern OCTINTERP_API octave_value elem_xpow (const FloatMatrix& a,
162 const FloatMatrix& b);
163extern OCTINTERP_API octave_value elem_xpow (const FloatMatrix& a,
164 const FloatComplex& b);
165extern OCTINTERP_API octave_value elem_xpow (const FloatMatrix& a,
166 const FloatComplexMatrix& b);
167
168extern OCTINTERP_API octave_value elem_xpow (const FloatComplex& a,
169 const FloatMatrix& b);
170extern OCTINTERP_API octave_value elem_xpow (const FloatComplex& a,
171 const FloatComplexMatrix& b);
172
173extern OCTINTERP_API octave_value elem_xpow (const FloatComplexMatrix& a,
174 float b);
175extern OCTINTERP_API octave_value elem_xpow (const FloatComplexMatrix& a,
176 const FloatMatrix& b);
177extern OCTINTERP_API octave_value elem_xpow (const FloatComplexMatrix& a,
178 const FloatComplex& b);
179extern OCTINTERP_API octave_value elem_xpow (const FloatComplexMatrix& a,
180 const FloatComplexMatrix& b);
181
182extern OCTINTERP_API octave_value elem_xpow (float a, const FloatNDArray& b);
183extern OCTINTERP_API octave_value elem_xpow (float a,
184 const FloatComplexNDArray& b);
185
186extern OCTINTERP_API octave_value elem_xpow (const FloatNDArray& a, float b);
187extern OCTINTERP_API octave_value elem_xpow (const FloatNDArray& a,
188 const FloatNDArray& b);
189extern OCTINTERP_API octave_value elem_xpow (const FloatNDArray& a,
190 const FloatComplex& b);
191extern OCTINTERP_API octave_value elem_xpow (const FloatNDArray& a,
192 const FloatComplexNDArray& b);
193
194extern OCTINTERP_API octave_value elem_xpow (const FloatComplex& a,
195 const FloatNDArray& b);
196extern OCTINTERP_API octave_value elem_xpow (const FloatComplex& a,
197 const FloatComplexNDArray& b);
198
199extern OCTINTERP_API octave_value elem_xpow (const FloatComplexNDArray& a,
200 float b);
201extern OCTINTERP_API octave_value elem_xpow (const FloatComplexNDArray& a,
202 const FloatNDArray& b);
203extern OCTINTERP_API octave_value elem_xpow (const FloatComplexNDArray& a,
204 const FloatComplex& b);
205extern OCTINTERP_API octave_value elem_xpow (const FloatComplexNDArray& a,
206 const FloatComplexNDArray& b);
207
208OCTAVE_NAMESPACE_END
209
210#if defined (OCTAVE_PROVIDE_DEPRECATED_SYMBOLS)
211
212OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
213inline octave_value
214xpow (double a, double b)
215{
216 return octave::xpow (a, b);
217}
218
219OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
220inline octave_value
221xpow (double a, const Matrix& b)
222{
223 return octave::xpow (a, b);
224}
225
226OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
227inline octave_value
228xpow (double a, const Complex& b)
229{
230 return octave::xpow (a, b);
231}
232
233OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
234inline octave_value
235xpow (double a, const ComplexMatrix& b)
236{
237 return octave::xpow (a, b);
238}
239
240OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
241inline octave_value
242xpow (const Matrix& a, double b)
243{
244 return octave::xpow (a, b);
245}
246
247OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
248inline octave_value
249xpow (const Matrix& a, const Complex& b)
250{
251 return octave::xpow (a, b);
252}
253
254OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
255inline octave_value
256xpow (const DiagMatrix& a, double b)
257{
258 return octave::xpow (a, b);
259}
260
261OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
262inline octave_value
263xpow (const DiagMatrix& a, const Complex& b)
264{
265 return octave::xpow (a, b);
266}
267
268OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
269inline octave_value
270xpow (const PermMatrix& a, double b)
271{
272 return octave::xpow (a, b);
273}
274
275OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
276inline octave_value
277xpow (const Complex& a, double b)
278{
279 return octave::xpow (a, b);
280}
281
282OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
283inline octave_value
284xpow (const Complex& a, const Matrix& b)
285{
286 return octave::xpow (a, b);
287}
288
289OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
290inline octave_value
291xpow (const Complex& a, const Complex& b)
292{
293 return octave::xpow (a, b);
294}
295
296OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
297inline octave_value
298xpow (const Complex& a, const ComplexMatrix& b)
299{
300 return octave::xpow (a, b);
301}
302
303OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
304inline octave_value
305xpow (const ComplexMatrix& a, double b)
306{
307 return octave::xpow (a, b);
308}
309
310OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
311inline octave_value
312xpow (const ComplexMatrix& a, const Complex& b)
313{
314 return octave::xpow (a, b);
315}
316
317OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
318inline octave_value
319xpow (const ComplexDiagMatrix& a, double b)
320{
321 return octave::xpow (a, b);
322}
323
324OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
325inline octave_value
326xpow (const ComplexDiagMatrix& a, const Complex& b)
327{
328 return octave::xpow (a, b);
329}
330
331OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
332inline octave_value
333elem_xpow (double a, const Matrix& b)
334{
335 return octave::elem_xpow (a, b);
336}
337
338OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
339inline octave_value
340elem_xpow (double a, const ComplexMatrix& b)
341{
342 return octave::elem_xpow (a, b);
343}
344
345OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
346inline octave_value
347elem_xpow (double a, const octave::range<double>& r)
348{
349 return octave::elem_xpow (a, r);
350}
351
352OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
353inline octave_value
354elem_xpow (const Matrix& a, double b)
355{
356 return octave::elem_xpow (a, b);
357}
358
359OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
360inline octave_value
361elem_xpow (const Matrix& a, const Matrix& b)
362{
363 return octave::elem_xpow (a, b);
364}
365
366OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
367inline octave_value
368elem_xpow (const Matrix& a, const Complex& b)
369{
370 return octave::elem_xpow (a, b);
371}
372
373OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
374inline octave_value
375elem_xpow (const Matrix& a, const ComplexMatrix& b)
376{
377 return octave::elem_xpow (a, b);
378}
379
380OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
381inline octave_value
382elem_xpow (const Complex& a, const Matrix& b)
383{
384 return octave::elem_xpow (a, b);
385}
386
387OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
388inline octave_value
389elem_xpow (const Complex& a, const ComplexMatrix& b)
390{
391 return octave::elem_xpow (a, b);
392}
393
394OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
395inline octave_value
396elem_xpow (const Complex& a, const octave::range<double>& r)
397{
398 return octave::elem_xpow (a, r);
399}
400
401OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
402inline octave_value
403elem_xpow (const ComplexMatrix& a, double b)
404{
405 return octave::elem_xpow (a, b);
406}
407
408OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
409inline octave_value
410elem_xpow (const ComplexMatrix& a, const Matrix& b)
411{
412 return octave::elem_xpow (a, b);
413}
414
415OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
416inline octave_value
417elem_xpow (const ComplexMatrix& a, const Complex& b)
418{
419 return octave::elem_xpow (a, b);
420}
421
422OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
423inline octave_value
424elem_xpow (const ComplexMatrix& a, const ComplexMatrix& b)
425{
426 return octave::elem_xpow (a, b);
427}
428
429OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
430inline octave_value
431elem_xpow (double a, const NDArray& b)
432{
433 return octave::elem_xpow (a, b);
434}
435
436OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
437inline octave_value
438elem_xpow (double a, const ComplexNDArray& b)
439{
440 return octave::elem_xpow (a, b);
441}
442
443OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
444inline octave_value
445elem_xpow (const NDArray& a, double b)
446{
447 return octave::elem_xpow (a, b);
448}
449
450OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
451inline octave_value
452elem_xpow (const NDArray& a, const NDArray& b)
453{
454 return octave::elem_xpow (a, b);
455}
456
457OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
458inline octave_value
459elem_xpow (const NDArray& a, const Complex& b)
460{
461 return octave::elem_xpow (a, b);
462}
463
464OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
465inline octave_value
466elem_xpow (const NDArray& a, const ComplexNDArray& b)
467{
468 return octave::elem_xpow (a, b);
469}
470
471OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
472inline octave_value
473elem_xpow (const Complex& a, const NDArray& b)
474{
475 return octave::elem_xpow (a, b);
476}
477
478OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
479inline octave_value
480elem_xpow (const Complex& a, const ComplexNDArray& b)
481{
482 return octave::elem_xpow (a, b);
483}
484
485OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
486inline octave_value
487elem_xpow (const ComplexNDArray& a, double b)
488{
489 return octave::elem_xpow (a, b);
490}
491
492OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
493inline octave_value
494elem_xpow (const ComplexNDArray& a, const NDArray& b)
495{
496 return octave::elem_xpow (a, b);
497}
498
499OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
500inline octave_value
501elem_xpow (const ComplexNDArray& a, const Complex& b)
502{
503 return octave::elem_xpow (a, b);
504}
505
506OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
507inline octave_value
508elem_xpow (const ComplexNDArray& a, const ComplexNDArray& b)
509{
510 return octave::elem_xpow (a, b);
511}
512
513OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
514inline octave_value
515xpow (float a, float b)
516{
517 return octave::xpow (a, b);
518}
519
520OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
521inline octave_value
522xpow (float a, const FloatMatrix& b)
523{
524 return octave::xpow (a, b);
525}
526
527OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
528inline octave_value
529xpow (float a, const FloatComplex& b)
530{
531 return octave::xpow (a, b);
532}
533
534OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
535inline octave_value
536xpow (float a, const FloatComplexMatrix& b)
537{
538 return octave::xpow (a, b);
539}
540
541OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
542inline octave_value
543xpow (const FloatMatrix& a, float b)
544{
545 return octave::xpow (a, b);
546}
547
548OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
549inline octave_value
550xpow (const FloatMatrix& a, const FloatComplex& b)
551{
552 return octave::xpow (a, b);
553}
554
555OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
556inline octave_value
557xpow (const FloatDiagMatrix& a, float b)
558{
559 return octave::xpow (a, b);
560}
561
562OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
563inline octave_value
564xpow (const FloatDiagMatrix& a, const FloatComplex& b)
565{
566 return octave::xpow (a, b);
567}
568
569OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
570inline octave_value
571xpow (const FloatComplex& a, float b)
572{
573 return octave::xpow (a, b);
574}
575
576OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
577inline octave_value
578xpow (const FloatComplex& a, const FloatMatrix& b)
579{
580 return octave::xpow (a, b);
581}
582
583OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
584inline octave_value
585xpow (const FloatComplex& a, const FloatComplex& b)
586{
587 return octave::xpow (a, b);
588}
589
590OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
591inline octave_value
592xpow (const FloatComplex& a, const FloatComplexMatrix& b)
593{
594 return octave::xpow (a, b);
595}
596
597OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
598inline octave_value
599xpow (const FloatComplexMatrix& a, float b)
600{
601 return octave::xpow (a, b);
602}
603
604OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
605inline octave_value
606xpow (const FloatComplexMatrix& a, const FloatComplex& b)
607{
608 return octave::xpow (a, b);
609}
610
611OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
612inline octave_value
613xpow (const FloatComplexDiagMatrix& a, float b)
614{
615 return octave::xpow (a, b);
616}
617
618OCTAVE_DEPRECATED (7, "use 'octave::xpow' instead")
619inline octave_value
620xpow (const FloatComplexDiagMatrix& a, const FloatComplex& b)
621{
622 return octave::xpow (a, b);
623}
624
625OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
626inline octave_value
627elem_xpow (float a, const FloatMatrix& b)
628{
629 return octave::elem_xpow (a, b);
630}
631
632OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
633inline octave_value
634elem_xpow (float a, const FloatComplexMatrix& b)
635{
636 return octave::elem_xpow (a, b);
637}
638
639OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
640inline octave_value
641elem_xpow (const FloatMatrix& a, float b)
642{
643 return octave::elem_xpow (a, b);
644}
645
646OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
647inline octave_value
648elem_xpow (const FloatMatrix& a, const FloatMatrix& b)
649{
650 return octave::elem_xpow (a, b);
651}
652
653OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
654inline octave_value
655elem_xpow (const FloatMatrix& a, const FloatComplex& b)
656{
657 return octave::elem_xpow (a, b);
658}
659
660OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
661inline octave_value
662elem_xpow (const FloatMatrix& a, const FloatComplexMatrix& b)
663{
664 return octave::elem_xpow (a, b);
665}
666
667OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
668inline octave_value
669elem_xpow (const FloatComplex& a, const FloatMatrix& b)
670{
671 return octave::elem_xpow (a, b);
672}
673
674OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
675inline octave_value
676elem_xpow (const FloatComplex& a, const FloatComplexMatrix& b)
677{
678 return octave::elem_xpow (a, b);
679}
680
681OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
682inline octave_value
683elem_xpow (const FloatComplexMatrix& a, float b)
684{
685 return octave::elem_xpow (a, b);
686}
687
688OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
689inline octave_value
690elem_xpow (const FloatComplexMatrix& a, const FloatMatrix& b)
691{
692 return octave::elem_xpow (a, b);
693}
694
695OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
696inline octave_value
697elem_xpow (const FloatComplexMatrix& a, const FloatComplex& b)
698{
699 return octave::elem_xpow (a, b);
700}
701
702OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
703inline octave_value
704elem_xpow (const FloatComplexMatrix& a, const FloatComplexMatrix& b)
705{
706 return octave::elem_xpow (a, b);
707}
708
709OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
710inline octave_value
711elem_xpow (float a, const FloatNDArray& b)
712{
713 return octave::elem_xpow (a, b);
714}
715
716OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
717inline octave_value
718elem_xpow (float a, const FloatComplexNDArray& b)
719{
720 return octave::elem_xpow (a, b);
721}
722
723OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
724inline octave_value
725elem_xpow (const FloatNDArray& a, float b)
726{
727 return octave::elem_xpow (a, b);
728}
729
730OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
731inline octave_value
732elem_xpow (const FloatNDArray& a, const FloatNDArray& b)
733{
734 return octave::elem_xpow (a, b);
735}
736
737OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
738inline octave_value
739elem_xpow (const FloatNDArray& a, const FloatComplex& b)
740{
741 return octave::elem_xpow (a, b);
742}
743
744OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
745inline octave_value
746elem_xpow (const FloatNDArray& a, const FloatComplexNDArray& b)
747{
748 return octave::elem_xpow (a, b);
749}
750
751OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
752inline octave_value
753elem_xpow (const FloatComplex& a, const FloatNDArray& b)
754{
755 return octave::elem_xpow (a, b);
756}
757
758OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
759inline octave_value
760elem_xpow (const FloatComplex& a, const FloatComplexNDArray& b)
761{
762 return octave::elem_xpow (a, b);
763}
764
765OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
766inline octave_value
767elem_xpow (const FloatComplexNDArray& a, float b)
768{
769 return octave::elem_xpow (a, b);
770}
771
772OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
773inline octave_value
774elem_xpow (const FloatComplexNDArray& a, const FloatNDArray& b)
775{
776 return octave::elem_xpow (a, b);
777}
778
779OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
780inline octave_value
781elem_xpow (const FloatComplexNDArray& a, const FloatComplex& b)
782{
783 return octave::elem_xpow (a, b);
784}
785
786OCTAVE_DEPRECATED (7, "use 'octave::elem_xpow' instead")
787inline octave_value
788elem_xpow (const FloatComplexNDArray& a, const FloatComplexNDArray& b)
789{
790 return octave::elem_xpow (a, b);
791}
792
793#endif
794
795#endif
Matrix
Definition: dMatrix.h:42
Range
Definition: Range.h:400
octave_value
Definition: ov.h:73
octave::range
class OCTAVE_API range
Definition: range-fwd.h:33
Complex
std::complex< double > Complex
Definition: oct-cmplx.h:33
FloatComplex
std::complex< float > FloatComplex
Definition: oct-cmplx.h:34
elem_xpow
OCTINTERP_API octave_value elem_xpow(double a, const Matrix &b)
Definition: xpow.cc:669
xpow
OCTAVE_NAMESPACE_BEGIN OCTINTERP_API octave_value xpow(double a, double b)
Definition: xpow.cc:108