octave-nkf: libinterp/corefcn/gcd.cc annotate

annotate libinterp/corefcn/gcd.cc @ 20762:f90c8372b7ba

eliminate many more simple uses of error_state * Cell.cc, __ichol__.cc, __ilu__.cc, balance.cc, bsxfun.cc, colloc.cc, det.cc, dlmread.cc, dynamic-ld.cc, eig.cc, fft.cc, fft2.cc, fftn.cc, gcd.cc, getgrent.cc, getpwent.cc, givens.cc, hess.cc, input.cc, levenshtein.cc, load-path.cc, lookup.cc, ls-mat-ascii.cc, ls-mat4.cc, lsode.cc, lu.cc, max.cc, md5sum.cc, mex.cc, pager.cc, pinv.cc, pr-output.cc, qz.cc, schur.cc, sparse.cc, sqrtm.cc, str2double.cc, strfns.cc, sub2ind.cc, sysdep.cc, time.cc, toplev.cc, tril.cc, tsearch.cc, typecast.cc, __init_gnuplot__.cc, __magick_read__.cc, __osmesa_print__.cc, amd.cc, audiodevinfo.cc, dmperm.cc, fftw.cc, symrcm.cc, ov-base-diag.cc, ov-base-sparse.cc, ov-base.cc, ov-bool-sparse.cc, ov-builtin.cc, ov-complex.cc, ov-cx-diag.cc, ov-cx-mat.cc, ov-cx-sparse.cc, ov-fcn-handle.cc, ov-fcn-inline.cc, ov-float.cc, ov-flt-complex.cc, ov-flt-cx-diag.cc, ov-flt-cx-mat.cc, ov-flt-re-diag.cc, ov-flt-re-mat.cc, ov-lazy-idx.cc, ov-mex-fcn.cc, ov-perm.cc, ov-range.cc, ov-re-diag.cc, ov-re-mat.cc, ov-re-sparse.cc, ov-scalar.cc, ov-str-mat.cc, op-bm-b.cc, op-bm-bm.cc, op-sbm-b.cc, op-sbm-bm.cc, op-str-m.cc, op-str-s.cc, oct-parse.in.yy, pt-cbinop.cc, pt-colon.cc, pt-decl.cc, pt-exp.cc, pt-id.cc, pt-misc.cc, pt-select.cc, pt-unop.cc: Eliminate simple uses of error_state.

author	John W. Eaton <jwe@octave.org>
date	Mon, 05 Oct 2015 19:29:36 -0400
parents	4f45eaf83908
children

rev	line source
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	1 /*
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	2
19898 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19341 diff changeset	3 Copyright (C) 2004-2015 David Bateman
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	4 Copyright (C) 2010 Jaroslav Hajek, Jordi Gutiérrez Hermoso
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	5
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	6 This file is part of Octave.
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	7
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	8 Octave is free software; you can redistribute it and/or modify it
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	9 under the terms of the GNU General Public License as published by the
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	10 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	11 option) any later version.
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	12
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	13 Octave is distributed in the hope that it will be useful, but WITHOUT
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	16 for more details.
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	17
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	18 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	19 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7001 diff changeset	20 <http://www.gnu.org/licenses/>.
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	21
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	22 */
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	23
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	24 #ifdef HAVE_CONFIG_H
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	25 #include <config.h>
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	26 #endif
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	27
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	28 #include "dNDArray.h"
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	29 #include "CNDArray.h"
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	30 #include "fNDArray.h"
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	31 #include "fCNDArray.h"
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	32 #include "lo-mappers.h"
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	33 #include "oct-binmap.h"
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	34
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	35 #include "defun.h"
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	36 #include "error.h"
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	37 #include "oct-obj.h"
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	38
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	39 static double
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	40 simple_gcd (double a, double b)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	41 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	42 if (! xisinteger (a) \|\| ! xisinteger (b))
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	43 (*current_liboctave_error_handler)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	44 ("gcd: all values must be integers");
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	45
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	46 double aa = fabs (a);
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	47 double bb = fabs (b);
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	48
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	49 while (bb != 0)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	50 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	51 double tt = fmod (aa, bb);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	52 aa = bb;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	53 bb = tt;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	54 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	55
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	56 return aa;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	57 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	58
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	59 // Don't use the Complex and FloatComplex typedefs because we need to
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	60 // refer to the actual float precision FP in the body (and when gcc
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	61 // implements template aliases from C++0x, can do a small fix here).
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	62 template <typename FP>
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	63 static void
11450 5eb10763069f substitute and use LAPACK_LIBS in mkoctfile script John W. Eaton <jwe@octave.org> parents: 11064 diff changeset	64 divide (const std::complex<FP>& a, const std::complex<FP>& b,
5eb10763069f substitute and use LAPACK_LIBS in mkoctfile script John W. Eaton <jwe@octave.org> parents: 11064 diff changeset	65 std::complex<FP>& q, std::complex<FP>& r)
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	66 {
11450 5eb10763069f substitute and use LAPACK_LIBS in mkoctfile script John W. Eaton <jwe@octave.org> parents: 11064 diff changeset	67 FP qr = gnulib::floor ((a/b).real () + 0.5);
5eb10763069f substitute and use LAPACK_LIBS in mkoctfile script John W. Eaton <jwe@octave.org> parents: 11064 diff changeset	68 FP qi = gnulib::floor ((a/b).imag () + 0.5);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	69
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	70 q = std::complex<FP> (qr, qi);
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	71
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	72 r = a - q*b;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	73 }
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	74
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	75 template <typename FP>
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	76 static std::complex<FP>
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	77 simple_gcd (const std::complex<FP>& a, const std::complex<FP>& b)
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	78 {
14854 5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	79 if (! xisinteger (a.real ()) \|\| ! xisinteger (a.imag ())
5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	80 \|\| ! xisinteger (b.real ()) \|\| ! xisinteger (b.imag ()))
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	81 (*current_liboctave_error_handler)
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	82 ("gcd: all complex parts must be integers");
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	83
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	84 std::complex<FP> aa = a;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	85 std::complex<FP> bb = b;
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	86
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	87 if (abs (aa) < abs (bb))
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	88 std::swap (aa, bb);
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	89
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	90 while (abs (bb) != 0)
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	91 {
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	92 std::complex<FP> qq, rr;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	93 divide (aa, bb, qq, rr);
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	94 aa = bb;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	95 bb = rr;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	96 }
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	97
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	98 return aa;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	99 }
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	100
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	101 template <class T>
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	102 static octave_int<T>
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	103 simple_gcd (const octave_int<T>& a, const octave_int<T>& b)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	104 {
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	105 T aa = a.abs ().value ();
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	106 T bb = b.abs ().value ();
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	107
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	108 while (bb != 0)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	109 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	110 T tt = aa % bb;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	111 aa = bb;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	112 bb = tt;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	113 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	114
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	115 return aa;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	116 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	117
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	118 static double
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	119 extended_gcd (double a, double b, double& x, double& y)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	120 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	121 if (! xisinteger (a) \|\| ! xisinteger (b))
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	122 (*current_liboctave_error_handler)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	123 ("gcd: all values must be integers");
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	124
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	125 double aa = fabs (a);
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	126 double bb = fabs (b);
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	127
18099 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	128 double xx, lx, yy, ly;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	129 xx = 0, lx = 1;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	130 yy = 1, ly = 0;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	131
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	132 while (bb != 0)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	133 {
11489 978802964923 tag call to floor with gnulib:: John W. Eaton <jwe@octave.org> parents: 11450 diff changeset	134 double qq = gnulib::floor (aa / bb);
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	135 double tt = fmod (aa, bb);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	136
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	137 aa = bb;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	138 bb = tt;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	139
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	140 double tx = lx - qq*xx;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	141 lx = xx;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	142 xx = tx;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	143
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	144 double ty = ly - qq*yy;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	145 ly = yy;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	146 yy = ty;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	147 }
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	148
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	149 x = a >= 0 ? lx : -lx;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	150 y = b >= 0 ? ly : -ly;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	151
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	152 return aa;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	153 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	154
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	155 template <typename FP>
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	156 static std::complex<FP>
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	157 extended_gcd (const std::complex<FP>& a, const std::complex<FP>& b,
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	158 std::complex<FP>& x, std::complex<FP>& y)
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	159 {
14854 5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	160 if (! xisinteger (a.real ()) \|\| ! xisinteger (a.imag ())
5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14501 diff changeset	161 \|\| ! xisinteger (b.real ()) \|\| ! xisinteger (b.imag ()))
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	162 (*current_liboctave_error_handler)
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	163 ("gcd: all complex parts must be integers");
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	164
18099 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	165 std::complex<FP> aa = a;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	166 std::complex<FP> bb = b;
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	167 bool swapped = false;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	168 if (abs (aa) < abs (bb))
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	169 {
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	170 std::swap (aa, bb);
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	171 swapped = true;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	172 }
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	173
18099 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	174 std::complex<FP> xx, lx, yy, ly;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	175 xx = 0, lx = 1;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	176 yy = 1, ly = 0;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	177
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	178 while (abs(bb) != 0)
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	179 {
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	180 std::complex<FP> qq, rr;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	181 divide (aa, bb, qq, rr);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	182 aa = bb;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	183 bb = rr;
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	184
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	185 std::complex<FP> tx = lx - qq*xx;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	186 lx = xx;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	187 xx = tx;
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	188
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	189 std::complex<FP> ty = ly - qq*yy;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	190 ly = yy;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	191 yy = ty;
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	192 }
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	193
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	194 x = lx;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	195 y = ly;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	196
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	197 if (swapped)
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	198 std::swap (x, y);
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	199
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	200 return aa;
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	201 }
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	202
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	203 template <class T>
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	204 static octave_int<T>
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	205 extended_gcd (const octave_int<T>& a, const octave_int<T>& b,
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	206 octave_int<T>& x, octave_int<T>& y)
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	207 {
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	208 T aa = a.abs ().value ();
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	209 T bb = b.abs ().value ();
18099 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	210 T xx, lx, yy, ly;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	211 xx = 0, lx = 1;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	212 yy = 1, ly = 0;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	213
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	214 while (bb != 0)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	215 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	216 T qq = aa / bb;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	217 T tt = aa % bb;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	218 aa = bb;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	219 bb = tt;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	220
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	221 T tx = lx - qq*xx;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	222 lx = xx;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	223 xx = tx;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	224
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	225 T ty = ly - qq*yy;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	226 ly = yy;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	227 yy = ty;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	228 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	229
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	230 x = octave_int<T> (lx) * a.signum ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	231 y = octave_int<T> (ly) * b.signum ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	232
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	233 return aa;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	234 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	235
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	236 template<class NDA>
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	237 static octave_value
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	238 do_simple_gcd (const octave_value& a, const octave_value& b)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	239 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	240 typedef typename NDA::element_type T;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	241 octave_value retval;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	242
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	243 if (a.is_scalar_type () && b.is_scalar_type ())
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	244 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	245 // Optimize scalar case.
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	246 T aa = octave_value_extract<T> (a);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	247 T bb = octave_value_extract<T> (b);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	248 retval = simple_gcd (aa, bb);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	249 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	250 else
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	251 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	252 NDA aa = octave_value_extract<NDA> (a);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	253 NDA bb = octave_value_extract<NDA> (b);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	254 retval = binmap<T> (aa, bb, simple_gcd, "gcd");
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	255 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	256
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	257 return retval;
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	258 }
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	259
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	260 // Dispatcher
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	261 static octave_value
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	262 do_simple_gcd (const octave_value& a, const octave_value& b)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	263 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	264 octave_value retval;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	265 builtin_type_t btyp = btyp_mixed_numeric (a.builtin_type (),
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	266 b.builtin_type ());
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	267 switch (btyp)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	268 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	269 case btyp_double:
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	270 if (a.is_sparse_type () && b.is_sparse_type ())
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	271 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	272 retval = do_simple_gcd<SparseMatrix> (a, b);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	273 break;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	274 }
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	275 // fall through!
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	276
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	277 case btyp_float:
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	278 retval = do_simple_gcd<NDArray> (a, b);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	279 break;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	280
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	281 #define MAKE_INT_BRANCH(X) \
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	282 case btyp_ ## X: \
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	283 retval = do_simple_gcd<X ## NDArray> (a, b); \
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	284 break
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	285
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	286 MAKE_INT_BRANCH (int8);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	287 MAKE_INT_BRANCH (int16);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	288 MAKE_INT_BRANCH (int32);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	289 MAKE_INT_BRANCH (int64);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	290 MAKE_INT_BRANCH (uint8);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	291 MAKE_INT_BRANCH (uint16);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	292 MAKE_INT_BRANCH (uint32);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	293 MAKE_INT_BRANCH (uint64);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	294
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	295 #undef MAKE_INT_BRANCH
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	296
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	297 case btyp_complex:
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	298 retval = do_simple_gcd<ComplexNDArray> (a, b);
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	299 break;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	300
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	301 case btyp_float_complex:
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	302 retval = do_simple_gcd<FloatComplexNDArray> (a, b);
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	303 break;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	304
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	305 default:
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	306 error ("gcd: invalid class combination for gcd: %s and %s\n",
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	307 a.class_name ().c_str (), b.class_name ().c_str ());
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	308 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	309
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	310 if (btyp == btyp_float)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	311 retval = retval.float_array_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	312
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	313 return retval;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	314 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	315
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	316 template<class NDA>
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	317 static octave_value
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	318 do_extended_gcd (const octave_value& a, const octave_value& b,
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	319 octave_value& x, octave_value& y)
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	320 {
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	321 typedef typename NDA::element_type T;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	322 octave_value retval;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	323
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	324 if (a.is_scalar_type () && b.is_scalar_type ())
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	325 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	326 // Optimize scalar case.
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	327 T aa = octave_value_extract<T> (a);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	328 T bb = octave_value_extract<T> (b);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	329 T xx, yy;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	330 retval = extended_gcd (aa, bb, xx, yy);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	331 x = xx;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	332 y = yy;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	333 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	334 else
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	335 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	336 NDA aa = octave_value_extract<NDA> (a);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	337 NDA bb = octave_value_extract<NDA> (b);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	338
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	339 dim_vector dv = aa.dims ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	340 if (aa.numel () == 1)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	341 dv = bb.dims ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	342 else if (bb.numel () != 1 && bb.dims () != dv)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	343 gripe_nonconformant ("gcd", a.dims (), b.dims ());
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	344
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	345 NDA gg (dv), xx (dv), yy (dv);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	346
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	347 const T *aptr = aa.fortran_vec ();
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	348 const T *bptr = bb.fortran_vec ();
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	349
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	350 bool inca = aa.numel () != 1;
61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	351 bool incb = bb.numel () != 1;
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	352
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	353 T *gptr = gg.fortran_vec ();
18099 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	354 T *xptr = xx.fortran_vec ();
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	355 T *yptr = yy.fortran_vec ();
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	356
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	357 octave_idx_type n = gg.numel ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	358 for (octave_idx_type i = 0; i < n; i++)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	359 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	360 octave_quit ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	361
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	362 gptr++ = extended_gcd (aptr, bptr, xptr++, *yptr++);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	363
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	364 aptr += inca;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	365 bptr += incb;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	366 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	367
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	368 x = xx;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	369 y = yy;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	370
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	371 retval = gg;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	372 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	373
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	374 return retval;
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	375 }
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	376
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	377 // Dispatcher
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	378 static octave_value
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	379 do_extended_gcd (const octave_value& a, const octave_value& b,
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	380 octave_value& x, octave_value& y)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	381 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	382 octave_value retval;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	383
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	384 builtin_type_t btyp = btyp_mixed_numeric (a.builtin_type (),
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	385 b.builtin_type ());
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	386 switch (btyp)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	387 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	388 case btyp_double:
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	389 case btyp_float:
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	390 retval = do_extended_gcd<NDArray> (a, b, x, y);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	391 break;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	392
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	393 #define MAKE_INT_BRANCH(X) \
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	394 case btyp_ ## X: \
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	395 retval = do_extended_gcd<X ## NDArray> (a, b, x, y); \
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	396 break
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	397
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	398 MAKE_INT_BRANCH (int8);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	399 MAKE_INT_BRANCH (int16);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	400 MAKE_INT_BRANCH (int32);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	401 MAKE_INT_BRANCH (int64);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	402 MAKE_INT_BRANCH (uint8);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	403 MAKE_INT_BRANCH (uint16);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	404 MAKE_INT_BRANCH (uint32);
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	405 MAKE_INT_BRANCH (uint64);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	406
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	407 #undef MAKE_INT_BRANCH
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	408
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	409 case btyp_complex:
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	410 retval = do_extended_gcd<ComplexNDArray> (a, b, x, y);
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	411 break;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	412
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	413 case btyp_float_complex:
11062 88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	414 retval = do_extended_gcd<FloatComplexNDArray> (a, b, x, y);
88d78ee12ee8 Implement gcd for Gaussian (complex) integers Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11061 diff changeset	415 break;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	416
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	417 default:
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	418 error ("gcd: invalid class combination for gcd: %s and %s\n",
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	419 a.class_name ().c_str (), b.class_name ().c_str ());
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	420 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	421
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	422 // For consistency.
20762 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20382 diff changeset	423 if (a.is_sparse_type () && b.is_sparse_type ())
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	424 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	425 retval = retval.sparse_matrix_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	426 x = x.sparse_matrix_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	427 y = y.sparse_matrix_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	428 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	429
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	430 if (btyp == btyp_float)
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	431 {
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	432 retval = retval.float_array_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	433 x = x.float_array_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	434 y = y.float_array_value ();
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	435 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	436
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	437 return retval;
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	438 }
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	439
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	440 DEFUN (gcd, args, nargout,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	441 "-- texinfo --\n\
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	442 @deftypefn {Built-in Function} {@var{g} =} gcd (@var{a1}, @var{a2}, @dots{})\n\
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	443 @deftypefnx {Built-in Function} {[@var{g}, @var{v1}, @dots{}] =} gcd (@var{a1}, @var{a2}, @dots{})\n\
19341 8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	444 Compute the greatest common divisor of @var{a1}, @var{a2}, @dots{}.\n\
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	445 \n\
19341 8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	446 If more than one argument is given then all arguments must be the same size\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	447 or scalar. In this case the greatest common divisor is calculated for each\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	448 element individually. All elements must be ordinary or Gaussian (complex)\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	449 integers. Note that for Gaussian integers, the gcd is only unique up to a\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	450 phase factor (multiplication by 1, -1, i, or -i), so an arbitrary greatest\n\
20382 4f45eaf83908 doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 19898 diff changeset	451 common divisor among the four possible is returned.\n\
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	452 \n\
19341 8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	453 Optional return arguments @var{v1}, @dots{}, contain integer vectors such\n\
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	454 that,\n\
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	455 \n\
9167 1231b1762a9a Simplify TeXinfo and eliminate use of @iftex in arith.txi Rik <rdrider0-list@yahoo.com> parents: 9141 diff changeset	456 @tex\n\
1231b1762a9a Simplify TeXinfo and eliminate use of @iftex in arith.txi Rik <rdrider0-list@yahoo.com> parents: 9141 diff changeset	457 $g = v_1 a_1 + v_2 a_2 + \\cdots$\n\
1231b1762a9a Simplify TeXinfo and eliminate use of @iftex in arith.txi Rik <rdrider0-list@yahoo.com> parents: 9141 diff changeset	458 @end tex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8377 diff changeset	459 @ifnottex\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10552 diff changeset	460 \n\
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	461 @example\n\
6547 4fb053f24fd6 [project @ 2007-04-19 21:47:40 by jwe] jwe parents: 5985 diff changeset	462 @var{g} = @var{v1} .* @var{a1} + @var{v2} .* @var{a2} + @dots{}\n\
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	463 @end example\n\
10840 89f4d7e294cc Grammarcheck .cc files Rik <octave@nomad.inbox5.com> parents: 10552 diff changeset	464 \n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8377 diff changeset	465 @end ifnottex\n\
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	466 \n\
19341 8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	467 Example code:\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	468 \n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	469 @example\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	470 @group\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	471 gcd ([15, 9], [20, 18])\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	472 @result{} 5 9\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	473 @end group\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	474 @end example\n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	475 \n\
8b3b35fda568 doc: Improve docstring for gcd. Rik <rik@octave.org> parents: 19324 diff changeset	476 @seealso{lcm, factor, isprime}\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5307 diff changeset	477 @end deftypefn")
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	478 {
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	479 octave_value_list retval;
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	480
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	481 int nargin = args.length ();
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	482
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	483 if (nargin > 1)
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	484 {
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	485 if (nargout > 1)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9167 diff changeset	486 {
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	487 retval.resize (nargin + 1);
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	488
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	489 retval(0) = do_extended_gcd (args(0), args(1), retval(1), retval(2));
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	490
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	491 for (int j = 2; j < nargin; j++)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9167 diff changeset	492 {
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	493 octave_value x;
11061 604dfbaf5010 Fix off-by-one and typo bugs in gcd Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11021 diff changeset	494 retval(0) = do_extended_gcd (retval(0), args(j),
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	495 x, retval(j+1));
0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	496 for (int i = 0; i < j; i++)
11061 604dfbaf5010 Fix off-by-one and typo bugs in gcd Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11021 diff changeset	497 retval(i+1).assign (octave_value::op_el_mul_eq, x);
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9167 diff changeset	498 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9167 diff changeset	499 }
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	500 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9167 diff changeset	501 {
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	502 retval(0) = do_simple_gcd (args(0), args(1));
11064 61a6c99d8ff7 gcd.cc: style fixes John W. Eaton <jwe@octave.org> parents: 11062 diff changeset	503
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	504 for (int j = 2; j < nargin; j++)
20762 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20382 diff changeset	505 retval(0) = do_simple_gcd (retval(0), args(j));
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 9167 diff changeset	506 }
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	507 }
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	508 else
11021 0ee74d581c00 optimize & rewrite gcd Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	509 print_usage ();
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	510
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	511 return retval;
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	512 }
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	513
d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	514 /*
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	515 %!assert (gcd (200, 300, 50, 35), 5)
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	516 %!assert (gcd (int16 (200), int16 (300), int16 (50), int16 (35)), int16 (5))
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	517 %!assert (gcd (uint64 (200), uint64 (300), uint64 (50), uint64 (35)), uint64 (5))
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	518 %!assert (gcd (18-i, -29+3i), -3-4i)
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	519
19324 c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	520 %!test
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	521 %! p = [953 967];
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	522 %! u = [953 + i971, 967 + i977];
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	523 %! [d, k(1), k(2)] = gcd (p(1), p(2));
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	524 %! [z, w(1), w(2)] = gcd (u(1), u(2));
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	525 %! assert (d, 1)
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	526 %! assert (sum (p.*k), d)
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	527 %! assert (abs (z), sqrt (2))
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	528 %! assert (abs (sum (u.*w)), sqrt (2))
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	529
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	530 %!error <all values must be integers> gcd (1/2, 2);
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	531 %!error <all complex parts must be integers> gcd (e + i*pi, 1);
c3bdd640a4dd * gcd.cc: add more tests Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18099 diff changeset	532
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	533 %!error gcd ()
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	534
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	535 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7017 diff changeset	536 %! s.a = 1;
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14360 diff changeset	537 %! fail ("gcd (s)");
4864 d49d761c8c93 [project @ 2004-04-16 16:01:11 by jwe] jwe parents: diff changeset	538 */

Mercurial > hg > octave-nkf

annotate libinterp/corefcn/gcd.cc @ 20762:f90c8372b7ba