1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
|
<!DOCTYPE html>
<html>
<!-- Created by GNU Texinfo 7.1.1, https://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Utility Functions (GNU Octave (version 10.3.0))</title>
<meta name="description" content="Utility Functions (GNU Octave (version 10.3.0))">
<meta name="keywords" content="Utility Functions (GNU Octave (version 10.3.0))">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta name="viewport" content="width=device-width,initial-scale=1">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Arithmetic.html" rel="up" title="Arithmetic">
<link href="Special-Functions.html" rel="next" title="Special Functions">
<link href="Sums-and-Products.html" rel="prev" title="Sums and Products">
<style type="text/css">
<!--
a.copiable-link {visibility: hidden; text-decoration: none; line-height: 0em}
div.example {margin-left: 3.2em}
span:hover a.copiable-link {visibility: visible}
strong.def-name {font-family: monospace; font-weight: bold; font-size: larger}
-->
</style>
<link rel="stylesheet" type="text/css" href="octave.css">
</head>
<body lang="en">
<div class="section-level-extent" id="Utility-Functions">
<div class="nav-panel">
<p>
Next: <a href="Special-Functions.html" accesskey="n" rel="next">Special Functions</a>, Previous: <a href="Sums-and-Products.html" accesskey="p" rel="prev">Sums and Products</a>, Up: <a href="Arithmetic.html" accesskey="u" rel="up">Arithmetic</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<h3 class="section" id="Utility-Functions-1"><span>17.5 Utility Functions<a class="copiable-link" href="#Utility-Functions-1"> ¶</a></span></h3>
<a class="anchor" id="XREFceil"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-ceil"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">ceil</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-ceil"> ¶</a></span></dt>
<dd><p>Return the smallest integer not less than <var class="var">x</var>.
</p>
<p>This is equivalent to rounding towards positive infinity.
</p>
<p>If <var class="var">x</var> is complex, return
<code class="code">ceil (real (<var class="var">x</var>)) + ceil (imag (<var class="var">x</var>)) * I</code>.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">ceil ([-2.7, 2.7])
⇒ -2 3
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFfloor">floor</a>, <a class="ref" href="#XREFround">round</a>, <a class="ref" href="#XREFfix">fix</a>.
</p></dd></dl>
<a class="anchor" id="XREFfix"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-fix"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">fix</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-fix"> ¶</a></span></dt>
<dd><p>Truncate fractional portion of <var class="var">x</var> and return the integer portion.
</p>
<p>This is equivalent to rounding towards zero. If <var class="var">x</var> is complex, return
<code class="code">fix (real (<var class="var">x</var>)) + fix (imag (<var class="var">x</var>)) * I</code>.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">fix ([-2.7, 2.7])
⇒ -2 2
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFceil">ceil</a>, <a class="ref" href="#XREFfloor">floor</a>, <a class="ref" href="#XREFround">round</a>.
</p></dd></dl>
<a class="anchor" id="XREFfloor"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-floor"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">floor</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-floor"> ¶</a></span></dt>
<dd><p>Return the largest integer not greater than <var class="var">x</var>.
</p>
<p>This is equivalent to rounding towards negative infinity. If <var class="var">x</var> is
complex, return <code class="code">floor (real (<var class="var">x</var>)) + floor (imag (<var class="var">x</var>)) * I</code>.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">floor ([-2.7, 2.7])
⇒ -3 2
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFceil">ceil</a>, <a class="ref" href="#XREFround">round</a>, <a class="ref" href="#XREFfix">fix</a>.
</p></dd></dl>
<a class="anchor" id="XREFround"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-round"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">round</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-round"> ¶</a></span></dt>
<dd><p>Return the integer nearest to <var class="var">x</var>.
</p>
<p>If <var class="var">x</var> is complex, return
<code class="code">round (real (<var class="var">x</var>)) + round (imag (<var class="var">x</var>)) * I</code>. If there
are two nearest integers, return the one further away from zero.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">round ([-2.7, 2.7])
⇒ -3 3
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFceil">ceil</a>, <a class="ref" href="#XREFfloor">floor</a>, <a class="ref" href="#XREFfix">fix</a>, <a class="ref" href="#XREFroundb">roundb</a>.
</p></dd></dl>
<a class="anchor" id="XREFroundb"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-roundb"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">roundb</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-roundb"> ¶</a></span></dt>
<dd><p>Return the integer nearest to <var class="var">x</var>. If there are two nearest
integers, return the even one (banker’s rounding).
</p>
<p>If <var class="var">x</var> is complex,
return <code class="code">roundb (real (<var class="var">x</var>)) + roundb (imag (<var class="var">x</var>)) * I</code>.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFround">round</a>.
</p></dd></dl>
<a class="anchor" id="XREFmax"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-max"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">max</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-max"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-max-1"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">max</strong> <code class="def-code-arguments">(<var class="var">x</var>, [], <var class="var">dim</var>)</code><a class="copiable-link" href="#index-max-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-max-2"><span><code class="def-type">[<var class="var">m</var>, <var class="var">im</var>] =</code> <strong class="def-name">max</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-max-2"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-max-3"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">max</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-max-3"> ¶</a></span></dt>
<dd><p>Find maximum values in the array <var class="var">x</var>.
</p>
<p>For a vector argument, return the maximum value. For a matrix argument,
return a row vector with the maximum value of each column. For a
multi-dimensional array, <code class="code">max</code> operates along the first non-singleton
dimension.
</p>
<p>If the optional third argument <var class="var">dim</var> is present then operate along
this dimension. In this case the second argument is ignored and should be
set to the empty matrix.
</p>
<p>For two inputs (<var class="var">x</var> and <var class="var">y</var>), return the pairwise maximum according to
the rules for <a class="ref" href="Broadcasting.html">Broadcasting</a>.
</p>
<p>Thus,
</p>
<div class="example">
<pre class="example-preformatted">max (max (<var class="var">x</var>))
</pre></div>
<p>returns the largest element of the 2-D matrix <var class="var">x</var>, and
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">max (2:5, pi)
⇒ 3.1416 3.1416 4.0000 5.0000
</pre></div></div>
<p>compares each element of the range <code class="code">2:5</code> with <code class="code">pi</code>, and returns a
row vector of the maximum values.
</p>
<p>For complex arguments, the magnitude of the elements are used for
comparison. If the magnitudes are identical, then the results are ordered
by phase angle in the range (-pi, pi]. Hence,
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">max ([-1 i 1 -i])
⇒ -1
</pre></div></div>
<p>because all entries have magnitude 1, but -1 has the largest phase angle
with value pi.
</p>
<p>If called with one input and two output arguments, <code class="code">max</code> also returns
the first index of the maximum value(s). Thus,
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">[x, ix] = max ([1, 3, 5, 2, 5])
⇒ x = 5
ix = 3
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFmin">min</a>, <a class="ref" href="#XREFcummax">cummax</a>, <a class="ref" href="#XREFcummin">cummin</a>.
</p></dd></dl>
<a class="anchor" id="XREFmin"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-min"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">min</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-min"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-min-1"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">min</strong> <code class="def-code-arguments">(<var class="var">x</var>, [], <var class="var">dim</var>)</code><a class="copiable-link" href="#index-min-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-min-2"><span><code class="def-type">[<var class="var">m</var>, <var class="var">im</var>] =</code> <strong class="def-name">min</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-min-2"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-min-3"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">min</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-min-3"> ¶</a></span></dt>
<dd><p>Find minimum values in the array <var class="var">x</var>.
</p>
<p>For a vector argument, return the minimum value. For a matrix argument,
return a row vector with the minimum value of each column. For a
multi-dimensional array, <code class="code">min</code> operates along the first non-singleton
dimension.
</p>
<p>If the optional third argument <var class="var">dim</var> is present then operate along
this dimension. In this case the second argument is ignored and should be
set to the empty matrix.
</p>
<p>For two inputs (<var class="var">x</var> and <var class="var">y</var>), return the pairwise minimum according to
the rules for <a class="ref" href="Broadcasting.html">Broadcasting</a>.
</p>
<p>Thus,
</p>
<div class="example">
<pre class="example-preformatted">min (min (<var class="var">x</var>))
</pre></div>
<p>returns the smallest element of the 2-D matrix <var class="var">x</var>, and
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">min (2:5, pi)
⇒ 2.0000 3.0000 3.1416 3.1416
</pre></div></div>
<p>compares each element of the range <code class="code">2:5</code> with <code class="code">pi</code>, and returns a
row vector of the minimum values.
</p>
<p>For complex arguments, the magnitude of the elements are used for
comparison. If the magnitudes are identical, then the results are ordered
by phase angle in the range (-pi, pi]. Hence,
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">min ([-1 i 1 -i])
⇒ -i
</pre></div></div>
<p>because all entries have magnitude 1, but -i has the smallest phase angle
with value -pi/2.
</p>
<p>If called with one input and two output arguments, <code class="code">min</code> also returns
the first index of the minimum value(s). Thus,
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">[x, ix] = min ([1, 3, 0, 2, 0])
⇒ x = 0
ix = 3
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFmax">max</a>, <a class="ref" href="#XREFcummin">cummin</a>, <a class="ref" href="#XREFcummax">cummax</a>.
</p></dd></dl>
<a class="anchor" id="XREFcummax"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-cummax"><span><code class="def-type"><var class="var">M</var> =</code> <strong class="def-name">cummax</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-cummax"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-cummax-1"><span><code class="def-type"><var class="var">M</var> =</code> <strong class="def-name">cummax</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">dim</var>)</code><a class="copiable-link" href="#index-cummax-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-cummax-2"><span><code class="def-type">[<var class="var">M</var>, <var class="var">IM</var>] =</code> <strong class="def-name">cummax</strong> <code class="def-code-arguments">(…)</code><a class="copiable-link" href="#index-cummax-2"> ¶</a></span></dt>
<dd><p>Return the cumulative maximum values along dimension <var class="var">dim</var>.
</p>
<p>If <var class="var">dim</var> is unspecified it defaults to column-wise operation. For
example:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">cummax ([1 3 2 6 4 5])
⇒ 1 3 3 6 6 6
</pre></div></div>
<p>If called with two output arguments the index of the maximum value is also
returned.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">[w, iw] = cummax ([1 3 2 6 4 5])
⇒
M = 1 3 3 6 6 6
IM = 1 2 2 4 4 4
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFcummin">cummin</a>, <a class="ref" href="#XREFmax">max</a>, <a class="ref" href="#XREFmin">min</a>.
</p></dd></dl>
<a class="anchor" id="XREFcummin"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-cummin"><span><code class="def-type"><var class="var">M</var> =</code> <strong class="def-name">cummin</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-cummin"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-cummin-1"><span><code class="def-type"><var class="var">M</var> =</code> <strong class="def-name">cummin</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">dim</var>)</code><a class="copiable-link" href="#index-cummin-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-cummin-2"><span><code class="def-type">[<var class="var">M</var>, <var class="var">IM</var>] =</code> <strong class="def-name">cummin</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-cummin-2"> ¶</a></span></dt>
<dd><p>Return the cumulative minimum values along dimension <var class="var">dim</var>.
</p>
<p>If <var class="var">dim</var> is unspecified it defaults to column-wise operation. For
example:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">cummin ([5 4 6 2 3 1])
⇒ 5 4 4 2 2 1
</pre></div></div>
<p>If called with two output arguments the index of the minimum value is also
returned.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">[M, IM] = cummin ([5 4 6 2 3 1])
⇒
M = 5 4 4 2 2 1
IM = 1 2 2 4 4 6
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFcummax">cummax</a>, <a class="ref" href="#XREFmin">min</a>, <a class="ref" href="#XREFmax">max</a>.
</p></dd></dl>
<a class="anchor" id="XREFhypot"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-hypot"><span><code class="def-type"><var class="var">h</var> =</code> <strong class="def-name">hypot</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-hypot"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-hypot-1"><span><code class="def-type"><var class="var">h</var> =</code> <strong class="def-name">hypot</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">z</var>, …)</code><a class="copiable-link" href="#index-hypot-1"> ¶</a></span></dt>
<dd><p>Compute the element-by-element square root of the sum of the squares of
<var class="var">x</var> and <var class="var">y</var>.
</p>
<p>This is equivalent to
<code class="code">sqrt (<var class="var">x</var>.^2 + <var class="var">y</var>.^2)</code>, but is calculated in a manner that
avoids overflows for large values of <var class="var">x</var> or <var class="var">y</var>.
</p>
<p><code class="code">hypot</code> can also be called with more than 2 arguments; in this case,
the arguments are accumulated from left to right:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">hypot (hypot (<var class="var">x</var>, <var class="var">y</var>), <var class="var">z</var>)
hypot (hypot (hypot (<var class="var">x</var>, <var class="var">y</var>), <var class="var">z</var>), <var class="var">w</var>), etc.
</pre></div></div>
</dd></dl>
<a class="anchor" id="XREFgradient"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-gradient"><span><code class="def-type"><var class="var">dx</var> =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">m</var>)</code><a class="copiable-link" href="#index-gradient"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gradient-1"><span><code class="def-type">[<var class="var">dx</var>, <var class="var">dy</var>, <var class="var">dz</var>, …] =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">m</var>)</code><a class="copiable-link" href="#index-gradient-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gradient-2"><span><code class="def-type">[…] =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">m</var>, <var class="var">s</var>)</code><a class="copiable-link" href="#index-gradient-2"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gradient-3"><span><code class="def-type">[…] =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">m</var>, <var class="var">sx</var>, <var class="var">sy</var>, <var class="var">sz</var>, …)</code><a class="copiable-link" href="#index-gradient-3"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gradient-4"><span><code class="def-type">[…] =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">f</var>, <var class="var">x0</var>)</code><a class="copiable-link" href="#index-gradient-4"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gradient-5"><span><code class="def-type">[…] =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">f</var>, <var class="var">x0</var>, <var class="var">s</var>)</code><a class="copiable-link" href="#index-gradient-5"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gradient-6"><span><code class="def-type">[…] =</code> <strong class="def-name">gradient</strong> <code class="def-code-arguments">(<var class="var">f</var>, <var class="var">x0</var>, <var class="var">sx</var>, <var class="var">sy</var>, …)</code><a class="copiable-link" href="#index-gradient-6"> ¶</a></span></dt>
<dd>
<p>Calculate the gradient of sampled data or a function.
</p>
<div class="group"><pre class="verbatim"> d d d
grad F(x,y,z) = -- F(x,y,z) i + -- F(x,y,z) j + -- F(x,y,z) k
dx dy dz
</pre></div>
<p>If <var class="var">m</var> is a vector, calculate the one-dimensional numerical gradient of
<var class="var">m</var>. If <var class="var">m</var> is a matrix the gradient is calculated for each
dimension. The return argument(s) are the estimated partial derivatives
for each dimension at the specified sample points.
</p>
<p>The default spacing of between data points is 1. A constant spacing between
points can be specified with the <var class="var">s</var> parameter. If <var class="var">s</var> is a scalar,
the single spacing value is used for all dimensions. Otherwise, separate
values of the spacing can be supplied by the <var class="var">sx</var>, … arguments.
Scalar values specify an equidistant spacing. Vector values for the
<var class="var">sx</var>, … arguments specify the coordinate for that dimension. The
length must match the respective dimension of <var class="var">m</var>.
</p>
<p>If the first argument <var class="var">f</var> is a function handle, the gradient of the
function is calculated for the points in <var class="var">x0</var>. As with sampled data,
the spacing values between the points from which the gradient is estimated
can be set via the <var class="var">s</var> or <var class="var">dx</var>, <var class="var">dy</var>, … arguments. By
default a spacing of 1 is used, however this is normally overly large unless
the function is very slowly varying, and it is often necessary to specify a
smaller sample spacing.
</p>
<p>Example: numerical gradient of <code class="code">cos</code> (analytically = <code class="code">-sin</code>)
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">gradient (@cos, pi/2, .1)
⇒ -0.9983
-sin (pi/2)
⇒ -1
</pre></div></div>
<p>Programming Notes:
The value for interior data points is approximated using the central
difference.
</p>
<div class="example">
<pre class="example-preformatted">y'(i) = 1/2 * (y(i+1) - y(i-1)).
</pre></div>
<p>At boundary points a linear extrapolation is applied.
</p>
<div class="example">
<pre class="example-preformatted">y'(1) = y(2) - y(1).
</pre></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="Finding-Elements-and-Checking-Conditions.html#XREFdiff">diff</a>, <a class="ref" href="#XREFdel2">del2</a>.
</p></dd></dl>
<a class="anchor" id="XREFdot"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-dot"><span><code class="def-type"><var class="var">z</var> =</code> <strong class="def-name">dot</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-dot"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-dot-1"><span><code class="def-type"><var class="var">z</var> =</code> <strong class="def-name">dot</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">dim</var>)</code><a class="copiable-link" href="#index-dot-1"> ¶</a></span></dt>
<dd><p>Compute the dot product of two vectors.
</p>
<p>If <var class="var">x</var> and <var class="var">y</var> are matrices, calculate the dot products along the
first non-singleton dimension.
</p>
<p>If the optional argument <var class="var">dim</var> is given, calculate the dot products
along this dimension.
</p>
<p>Implementation Note: This is equivalent to
<code class="code">sum (conj (<var class="var">X</var>) .* <var class="var">Y</var>, <var class="var">dim</var>)</code>, but avoids forming a
temporary array and is faster. When <var class="var">X</var> and <var class="var">Y</var> are column vectors,
the result is equivalent to <code class="code"><var class="var">X</var>' * <var class="var">Y</var></code>. Although, <code class="code">dot</code>
is defined for integer arrays, the output may differ from the expected result
due to the limited range of integer objects.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFcross">cross</a>, <a class="ref" href="#XREFdivergence">divergence</a>, <a class="ref" href="Functions-of-a-Matrix.html#XREFtensorprod">tensorprod</a>.
</p></dd></dl>
<a class="anchor" id="XREFcross"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-cross"><span><code class="def-type"><var class="var">z</var> =</code> <strong class="def-name">cross</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-cross"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-cross-1"><span><code class="def-type"><var class="var">z</var> =</code> <strong class="def-name">cross</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">dim</var>)</code><a class="copiable-link" href="#index-cross-1"> ¶</a></span></dt>
<dd><p>Compute the vector cross product of two 3-dimensional vectors <var class="var">x</var> and
<var class="var">y</var>.
</p>
<p>If <var class="var">x</var> and <var class="var">y</var> are arrays, the cross product is applied along the
first dimension with three elements.
</p>
<p>The optional argument <var class="var">dim</var> forces the cross product to be calculated
along the specified dimension. An error will be produced if the specified
dimension is not three elements in size.
</p>
<p>In the case of a complex output, orthogonality of the output with respect
to the inputs is also satisfied, and the condition
</p><div class="example">
<pre class="example-preformatted"><code class="code">dot (conj (<var class="var">z</var>), <var class="var">x</var>) ≡ dot (conj (<var class="var">z</var>), <var class="var">y</var>) = 0</code>
</pre></div>
<p>is met. <code class="code">dot (<var class="var">z</var>, <var class="var">x</var>) = 0</code> and
<code class="code">dot (<var class="var">z</var>, <var class="var">y</var>) = 0</code> will not hold. Also note that instead of
using the <code class="code">dot</code> function, the inner product
</p><div class="example">
<pre class="example-preformatted"><code class="code"><var class="var">z</var>(:).' * <var class="var">x</var>(:) ≡ <var class="var">z</var>(:).' * <var class="var">y</var>(:) = 0</code>
</pre></div>
<p>will meet the orthogonality condition for vector input.
</p>
<p>Example Code:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">cross ([1, 1, 0], [0, 1, 1])
⇒
1 -1 1
</pre></div></div>
<div class="example">
<div class="group"><pre class="example-preformatted">cross (magic (3), eye (3), 2)
⇒
0 6 -1
-7 0 3
9 -4 0
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFdot">dot</a>, <a class="ref" href="#XREFcurl">curl</a>, <a class="ref" href="#XREFdivergence">divergence</a>, <a class="ref" href="Complex-Arithmetic.html#XREFconj">conj</a>.
</p></dd></dl>
<a class="anchor" id="XREFdivergence"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-divergence"><span><code class="def-type"><var class="var">div</var> =</code> <strong class="def-name">divergence</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">z</var>, <var class="var">fx</var>, <var class="var">fy</var>, <var class="var">fz</var>)</code><a class="copiable-link" href="#index-divergence"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-divergence-1"><span><code class="def-type"><var class="var">div</var> =</code> <strong class="def-name">divergence</strong> <code class="def-code-arguments">(<var class="var">fx</var>, <var class="var">fy</var>, <var class="var">fz</var>)</code><a class="copiable-link" href="#index-divergence-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-divergence-2"><span><code class="def-type"><var class="var">div</var> =</code> <strong class="def-name">divergence</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">fx</var>, <var class="var">fy</var>)</code><a class="copiable-link" href="#index-divergence-2"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-divergence-3"><span><code class="def-type"><var class="var">div</var> =</code> <strong class="def-name">divergence</strong> <code class="def-code-arguments">(<var class="var">fx</var>, <var class="var">fy</var>)</code><a class="copiable-link" href="#index-divergence-3"> ¶</a></span></dt>
<dd><p>Calculate divergence of a vector field given by the arrays <var class="var">fx</var>,
<var class="var">fy</var>, and <var class="var">fz</var> or <var class="var">fx</var>, <var class="var">fy</var> respectively.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted"> d d d
div F(x,y,z) = -- F(x,y,z) + -- F(x,y,z) + -- F(x,y,z)
dx dy dz
</pre></div></div>
<p>The coordinates of the vector field can be given by the arguments <var class="var">x</var>,
<var class="var">y</var>, <var class="var">z</var> or <var class="var">x</var>, <var class="var">y</var> respectively.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFcurl">curl</a>, <a class="ref" href="#XREFgradient">gradient</a>, <a class="ref" href="#XREFdel2">del2</a>, <a class="ref" href="#XREFdot">dot</a>.
</p></dd></dl>
<a class="anchor" id="XREFcurl"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-curl"><span><code class="def-type">[<var class="var">cx</var>, <var class="var">cy</var>, <var class="var">cz</var>, <var class="var">v</var>] =</code> <strong class="def-name">curl</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">z</var>, <var class="var">fx</var>, <var class="var">fy</var>, <var class="var">fz</var>)</code><a class="copiable-link" href="#index-curl"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-curl-1"><span><code class="def-type">[<var class="var">cz</var>, <var class="var">v</var>] =</code> <strong class="def-name">curl</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, <var class="var">fx</var>, <var class="var">fy</var>)</code><a class="copiable-link" href="#index-curl-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-curl-2"><span><code class="def-type">[…] =</code> <strong class="def-name">curl</strong> <code class="def-code-arguments">(<var class="var">fx</var>, <var class="var">fy</var>, <var class="var">fz</var>)</code><a class="copiable-link" href="#index-curl-2"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-curl-3"><span><code class="def-type">[…] =</code> <strong class="def-name">curl</strong> <code class="def-code-arguments">(<var class="var">fx</var>, <var class="var">fy</var>)</code><a class="copiable-link" href="#index-curl-3"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-curl-4"><span><code class="def-type"><var class="var">v</var> =</code> <strong class="def-name">curl</strong> <code class="def-code-arguments">(…)</code><a class="copiable-link" href="#index-curl-4"> ¶</a></span></dt>
<dd><p>Calculate curl of vector field given by the arrays <var class="var">fx</var>, <var class="var">fy</var>, and
<var class="var">fz</var> or <var class="var">fx</var>, <var class="var">fy</var> respectively.
</p>
<div class="example">
<div class="group"><pre class="example-preformatted"> / d d d d d d \
curl F(x,y,z) = | -- Fz - -- Fy, -- Fx - -- Fz, -- Fy - -- Fx |
\ dy dz dz dx dx dy /
</pre></div></div>
<p>The coordinates of the vector field can be given by the arguments <var class="var">x</var>,
<var class="var">y</var>, <var class="var">z</var> or <var class="var">x</var>, <var class="var">y</var> respectively. <var class="var">v</var> calculates the
scalar component of the angular velocity vector in direction of the z-axis
for two-dimensional input. For three-dimensional input the scalar
rotation is calculated at each grid point in direction of the vector field
at that point.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFdivergence">divergence</a>, <a class="ref" href="#XREFgradient">gradient</a>, <a class="ref" href="#XREFdel2">del2</a>, <a class="ref" href="#XREFcross">cross</a>.
</p></dd></dl>
<a class="anchor" id="XREFdel2"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-del2"><span><code class="def-type"><var class="var">L</var> =</code> <strong class="def-name">del2</strong> <code class="def-code-arguments">(<var class="var">M</var>)</code><a class="copiable-link" href="#index-del2"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-del2-1"><span><code class="def-type"><var class="var">L</var> =</code> <strong class="def-name">del2</strong> <code class="def-code-arguments">(<var class="var">M</var>, <var class="var">h</var>)</code><a class="copiable-link" href="#index-del2-1"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-del2-2"><span><code class="def-type"><var class="var">L</var> =</code> <strong class="def-name">del2</strong> <code class="def-code-arguments">(<var class="var">M</var>, <var class="var">dx</var>, <var class="var">dy</var>, …)</code><a class="copiable-link" href="#index-del2-2"> ¶</a></span></dt>
<dd>
<p>Calculate the discrete Laplace
operator.
</p>
<p>For a 2-dimensional matrix <em class="math">M(x, y)</em> this is defined as
</p>
<div class="example">
<div class="group"><pre class="example-preformatted"> 1 / d^2 d^2 \
L = --- * | --- M(x,y) + --- M(x,y) |
4 \ dx^2 dy^2 /
</pre></div></div>
<p>For N-dimensional arrays the sum in parentheses is expanded to include
second derivatives over the additional higher dimensions.
</p>
<p>The spacing between evaluation points may be defined by <var class="var">h</var>, which is a
scalar defining the equidistant spacing in all dimensions. Alternatively,
the spacing in each dimension may be defined separately by <var class="var">dx</var>,
<var class="var">dy</var>, etc. A scalar spacing argument defines equidistant spacing,
whereas a vector argument can be used to specify variable spacing. The
length of the spacing vectors must match the respective dimension of
<var class="var">M</var>. The default spacing value is 1.
</p>
<p>Dimensions with fewer than 3 data points are skipped. Boundary points are
calculated from the linear extrapolation of interior points.
</p>
<p>Example: Second derivative of 2*x^3
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">f = @(x) 2*x.^3;
dd = @(x) 12*x;
x = 1:6;
L = 4*del2 (f(x));
assert (L, dd (x));
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFgradient">gradient</a>, <a class="ref" href="Finding-Elements-and-Checking-Conditions.html#XREFdiff">diff</a>.
</p></dd></dl>
<a class="anchor" id="XREFfactorial"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-factorial"><span><code class="def-type"><var class="var">f</var> =</code> <strong class="def-name">factorial</strong> <code class="def-code-arguments">(<var class="var">n</var>)</code><a class="copiable-link" href="#index-factorial"> ¶</a></span></dt>
<dd><p>Return the factorial of <var class="var">n</var> where <var class="var">n</var> is a real non-negative
integer.
</p>
<p>If <var class="var">n</var> is a scalar, this is equivalent to <code class="code">prod (1:<var class="var">n</var>)</code>. For
vector or matrix arguments, return the factorial of each element in the
array.
</p>
<p>For non-integers see the generalized factorial function <code class="code">gamma</code>.
Note that the factorial function grows large quite quickly, and even
with double precision values overflow will occur if <var class="var">n</var> > 171. For
such cases consider <code class="code">gammaln</code>.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="Sums-and-Products.html#XREFprod">prod</a>, <a class="ref" href="Special-Functions.html#XREFgamma">gamma</a>, <a class="ref" href="Special-Functions.html#XREFgammaln">gammaln</a>.
</p></dd></dl>
<a class="anchor" id="XREFfactor"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-factor"><span><code class="def-type"><var class="var">pf</var> =</code> <strong class="def-name">factor</strong> <code class="def-code-arguments">(<var class="var">q</var>)</code><a class="copiable-link" href="#index-factor"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-factor-1"><span><code class="def-type">[<var class="var">pf</var>, <var class="var">n</var>] =</code> <strong class="def-name">factor</strong> <code class="def-code-arguments">(<var class="var">q</var>)</code><a class="copiable-link" href="#index-factor-1"> ¶</a></span></dt>
<dd><p>Return the prime factorization of <var class="var">q</var>.
</p>
<p>The prime factorization is defined as <code class="code">prod (<var class="var">pf</var>) == <var class="var">q</var></code>
where every element of <var class="var">pf</var> is a prime number. If <code class="code"><var class="var">q</var> == 1</code>,
return 1. The output <var class="var">pf</var> is of the same numeric class as the input.
</p>
<p>With two output arguments, return the unique prime factors <var class="var">pf</var> and
their multiplicities. That is,
<code class="code">prod (<var class="var">pf</var> .^ <var class="var">n</var>) == <var class="var">q</var></code>.
</p>
<p>Implementation Note: If the input <var class="var">q</var> is <code class="code">single</code> or <code class="code">double</code>,
then it must not exceed the corresponding <code class="code">flintmax</code>. For larger
inputs, cast them to <code class="code">uint64</code> if they’re less than 2^64:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">factor (uint64 (18446744073709011493))
⇒ 571111 761213 42431951
</pre></div></div>
<p>For even larger inputs, use <code class="code">sym</code> if you have the Symbolic package
installed and loaded:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">factor (sym ('9444733049654361449941'))
⇒ (sym)
1 1
1099511627689 ⋅8589934669
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFgcd">gcd</a>, <a class="ref" href="#XREFlcm">lcm</a>, <a class="ref" href="Predicates-for-Numeric-Objects.html#XREFisprime">isprime</a>, <a class="ref" href="#XREFprimes">primes</a>.
</p></dd></dl>
<a class="anchor" id="XREFgcd"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-gcd"><span><code class="def-type"><var class="var">g</var> =</code> <strong class="def-name">gcd</strong> <code class="def-code-arguments">(<var class="var">a1</var>, <var class="var">a2</var>, …)</code><a class="copiable-link" href="#index-gcd"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-gcd-1"><span><code class="def-type">[<var class="var">g</var>, <var class="var">v1</var>, …] =</code> <strong class="def-name">gcd</strong> <code class="def-code-arguments">(<var class="var">a1</var>, <var class="var">a2</var>, …)</code><a class="copiable-link" href="#index-gcd-1"> ¶</a></span></dt>
<dd><p>Compute the greatest common divisor of <var class="var">a1</var>, <var class="var">a2</var>, <small class="enddots">...</small>
</p>
<p>All arguments must be the same size or scalar. For arrays, the greatest common
divisor is calculated for each element individually. All elements must be
ordinary or Gaussian (complex) integers. Note that for Gaussian integers, the
gcd is only unique up to a phase factor (multiplication by 1, -1, i, or -i), so
an arbitrary greatest common divisor among the four possible is returned.
</p>
<p>Optional return arguments <var class="var">v1</var>, …, contain integer vectors such
that,
</p>
<div class="example">
<pre class="example-preformatted"><var class="var">g</var> = <var class="var">v1</var> .* <var class="var">a1</var> + <var class="var">v2</var> .* <var class="var">a2</var> + ...
</pre></div>
<p>Example code:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">gcd ([15, 9], [20, 18])
⇒ 5 9
</pre></div></div>
<p>Programming tip: To find the GCD of all the elements of a single array, use
<code class="code">num2cell</code> instead of nested calls or a loop:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">x = [30 42 70 105]; # vector or array of inputs
gcd (num2cell (x) {:})
⇒ 1
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFlcm">lcm</a>, <a class="ref" href="#XREFfactor">factor</a>, <a class="ref" href="Predicates-for-Numeric-Objects.html#XREFisprime">isprime</a>.
</p></dd></dl>
<a class="anchor" id="XREFlcm"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-lcm"><span><code class="def-type"><var class="var">l</var> =</code> <strong class="def-name">lcm</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-lcm"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-lcm-1"><span><code class="def-type"><var class="var">l</var> =</code> <strong class="def-name">lcm</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>, …)</code><a class="copiable-link" href="#index-lcm-1"> ¶</a></span></dt>
<dd><p>Compute the least common multiple of <var class="var">x</var> and <var class="var">y</var>, or of the list of
all arguments.
</p>
<p>All inputs must be of the same size, or scalar. All elements must be
real integer or Gaussian (complex) integer. For complex inputs, the result
is unique only up to a phase factor (multiplication by +1, +i, -1, or -i),
and one of the four is returned arbitrarily.
</p>
<p>Example code:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">lcm (5:8, 9:12)
⇒ 45 30 77 24
</pre></div></div>
<p>Programming tip: To find the LCM of all the elements of a single array, use
<code class="code">num2cell</code> instead of nested calls or a loop:
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">x = 1:10; # vector or array of inputs
lcm (num2cell (x) {:})
⇒ 2520
</pre></div></div>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFfactor">factor</a>, <a class="ref" href="#XREFgcd">gcd</a>, <a class="ref" href="Predicates-for-Numeric-Objects.html#XREFisprime">isprime</a>.
</p></dd></dl>
<a class="anchor" id="XREFrem"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-rem"><span><code class="def-type"><var class="var">r</var> =</code> <strong class="def-name">rem</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-rem"> ¶</a></span></dt>
<dd><p>Return the remainder of the division <code class="code"><var class="var">x</var> / <var class="var">y</var></code>.
</p>
<p>The remainder is computed using the expression
</p>
<div class="example">
<pre class="example-preformatted">x - y .* fix (x ./ y)
</pre></div>
<p>An error message is printed if the dimensions of the arguments do not agree,
or if either argument is complex.
</p>
<p>Programming Notes: When calculating with floating point numbers (double,
single), values within a few eps of an integer will be rounded to that
integer before computation for compatibility with <small class="sc">MATLAB</small>. Any floating
point integers greater than <code class="code">flintmax</code> (2^53 for double) will not compute
correctly. For larger integer values convert the input to <code class="code">uint64</code> before
calling this function.
</p>
<p>By convention,
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">rem (<var class="var">x</var>, 0) = NaN if <var class="var">x</var> is a floating point variable
rem (<var class="var">x</var>, 0) = 0 if <var class="var">x</var> is an integer variable
rem (<var class="var">x</var>, <var class="var">y</var>) returns a value with the signbit from <var class="var">x</var>
</pre></div></div>
<p>For the opposite conventions see the <code class="code">mod</code> function. In general,
<code class="code">rem</code> is best when computing the remainder after division of two
<em class="emph">positive</em> numbers. For negative numbers, or when the values are
periodic, <code class="code">mod</code> is a better choice.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFmod">mod</a>.
</p></dd></dl>
<a class="anchor" id="XREFmod"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-mod"><span><code class="def-type"><var class="var">m</var> =</code> <strong class="def-name">mod</strong> <code class="def-code-arguments">(<var class="var">x</var>, <var class="var">y</var>)</code><a class="copiable-link" href="#index-mod"> ¶</a></span></dt>
<dd><p>Compute the modulo of <var class="var">x</var> and <var class="var">y</var>.
</p>
<p>Conceptually this is given by
</p>
<div class="example">
<pre class="example-preformatted">x - y .* floor (x ./ y)
</pre></div>
<p>and is written such that the correct modulus is returned for integer types.
This function handles negative values correctly. That is,
<code class="code">mod (-1, 3)</code><!-- /@w --> is 2, not -1, as <code class="code">rem (-1, 3)</code><!-- /@w --> returns.
</p>
<p>An error results if the dimensions of the arguments do not agree, or if
either of the arguments is complex.
</p>
<p>Programming Notes: When calculating with floating point numbers (double,
single), values within a few eps of an integer will be rounded to that
integer before computation for compatibility with <small class="sc">MATLAB</small>. Any floating
point integers greater than <code class="code">flintmax</code> (2^53 for double) will not compute
correctly. For larger integer values convert the input to <code class="code">uint64</code> before
calling this function.
</p>
<p>By convention,
</p>
<div class="example">
<div class="group"><pre class="example-preformatted">mod (<var class="var">x</var>, 0) = <var class="var">x</var>
mod (<var class="var">x</var>, <var class="var">y</var>) returns a value with the signbit from <var class="var">y</var>
</pre></div></div>
<p>For the opposite conventions see the <code class="code">rem</code> function. In general,
<code class="code">mod</code> is a better choice than <code class="code">rem</code> when any of the inputs are
negative numbers or when the values are periodic.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFrem">rem</a>.
</p></dd></dl>
<a class="anchor" id="XREFprimes"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-primes"><span><code class="def-type"><var class="var">p</var> =</code> <strong class="def-name">primes</strong> <code class="def-code-arguments">(<var class="var">n</var>)</code><a class="copiable-link" href="#index-primes"> ¶</a></span></dt>
<dd><p>Return all primes up to <var class="var">n</var>.
</p>
<p>The output data class (double, single, uint32, etc.) is the same as the
input class of <var class="var">n</var>. The algorithm used is the Sieve of Eratosthenes.
</p>
<p>Note: For a specific number <var class="var">n</var> of primes, call
<code class="code">list_primes (<var class="var">n</var>)</code>. Alternatively, call
<code class="code">primes (<var class="var">n</var>*log (<var class="var">k</var>*<var class="var">n</var>))(1:<var class="var">n</var>)</code> where <var class="var">k</var> is
about 5 or 6. This works because the distance from one prime to the next is
proportional to the logarithm of the prime, on average. On integrating,
there are about <var class="var">n</var> primes less than <code class="code"><var class="var">n</var> * log (5*<var class="var">n</var>)</code>.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFlist_005fprimes">list_primes</a>, <a class="ref" href="Predicates-for-Numeric-Objects.html#XREFisprime">isprime</a>.
</p></dd></dl>
<a class="anchor" id="XREFlist_005fprimes"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-list_005fprimes"><span><code class="def-type"><var class="var">p</var> =</code> <strong class="def-name">list_primes</strong> <code class="def-code-arguments">()</code><a class="copiable-link" href="#index-list_005fprimes"> ¶</a></span></dt>
<dt class="deftypefnx def-cmd-deftypefn" id="index-list_005fprimes-1"><span><code class="def-type"><var class="var">p</var> =</code> <strong class="def-name">list_primes</strong> <code class="def-code-arguments">(<var class="var">n</var>)</code><a class="copiable-link" href="#index-list_005fprimes-1"> ¶</a></span></dt>
<dd><p>List the first <var class="var">n</var> primes.
</p>
<p>If <var class="var">n</var> is unspecified, the first 25 primes are listed.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFprimes">primes</a>, <a class="ref" href="Predicates-for-Numeric-Objects.html#XREFisprime">isprime</a>.
</p></dd></dl>
<a class="anchor" id="XREFsign"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-sign"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">sign</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-sign"> ¶</a></span></dt>
<dd><p>Compute the <em class="dfn">signum</em> function.
</p>
<p>This is defined as
</p>
<div class="example">
<div class="group"><pre class="example-preformatted"> -1, x < 0;
sign (x) = 0, x = 0;
1, x > 0.
</pre></div></div>
<p>For complex arguments, <code class="code">sign</code> returns <code class="code">x ./ abs (<var class="var">x</var>)</code>.
</p>
<p>Note that <code class="code">sign (-0.0)</code> is 0. Although IEEE 754 floating point
allows zero to be signed, 0.0 and -0.0 compare equal. If you must test
whether zero is signed, use the <code class="code">signbit</code> function.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFsignbit">signbit</a>.
</p></dd></dl>
<a class="anchor" id="XREFsignbit"></a><span style="display:block; margin-top:-4.5ex;"> </span>
<dl class="first-deftypefn">
<dt class="deftypefn" id="index-signbit"><span><code class="def-type"><var class="var">y</var> =</code> <strong class="def-name">signbit</strong> <code class="def-code-arguments">(<var class="var">x</var>)</code><a class="copiable-link" href="#index-signbit"> ¶</a></span></dt>
<dd><p>Return logical true if the value of <var class="var">x</var> has its sign bit set and false
otherwise.
</p>
<p>This behavior is consistent with the other logical functions.
See <a class="xref" href="Logical-Values.html">Logical Values</a>. The behavior differs from the C language function
which returns nonzero if the sign bit is set.
</p>
<p>This is not the same as <code class="code">x < 0.0</code>, because IEEE 754 floating point
allows zero to be signed. The comparison <code class="code">-0.0 < 0.0</code> is false,
but <code class="code">signbit (-0.0)</code> will return a nonzero value.
</p>
<p><strong class="strong">See also:</strong> <a class="ref" href="#XREFsign">sign</a>.
</p></dd></dl>
</div>
<hr>
<div class="nav-panel">
<p>
Next: <a href="Special-Functions.html">Special Functions</a>, Previous: <a href="Sums-and-Products.html">Sums and Products</a>, Up: <a href="Arithmetic.html">Arithmetic</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>
|
