0
# Mathematical Operations
1
2
Comprehensive collection of mathematical functions providing GPU-accelerated computation for trigonometric, hyperbolic, exponential, logarithmic, arithmetic, and statistical operations with full NumPy compatibility.
3
4
## Capabilities
5
6
### Trigonometric Functions
7
8
GPU-accelerated trigonometric functions for angles in radians.
9
10
```python { .api }
11
def sin(x, out=None, **kwargs):
12
"""
13
Trigonometric sine, element-wise.
14
15
Parameters:
16
- x: array-like, input angles in radians
17
- out: ndarray, optional output array
18
19
Returns:
20
cupy.ndarray
21
"""
22
23
def cos(x, out=None, **kwargs):
24
"""
25
Trigonometric cosine, element-wise.
26
27
Parameters:
28
- x: array-like, input angles in radians
29
- out: ndarray, optional output array
30
31
Returns:
32
cupy.ndarray
33
"""
34
35
def tan(x, out=None, **kwargs):
36
"""
37
Trigonometric tangent, element-wise.
38
39
Parameters:
40
- x: array-like, input angles in radians
41
- out: ndarray, optional output array
42
43
Returns:
44
cupy.ndarray
45
"""
46
47
def arcsin(x, out=None, **kwargs):
48
"""
49
Inverse sine, element-wise.
50
51
Parameters:
52
- x: array-like, input values in [-1, 1]
53
- out: ndarray, optional output array
54
55
Returns:
56
cupy.ndarray, angles in radians in [-pi/2, pi/2]
57
"""
58
59
def arccos(x, out=None, **kwargs):
60
"""
61
Inverse cosine, element-wise.
62
63
Parameters:
64
- x: array-like, input values in [-1, 1]
65
- out: ndarray, optional output array
66
67
Returns:
68
cupy.ndarray, angles in radians in [0, pi]
69
"""
70
71
def arctan(x, out=None, **kwargs):
72
"""
73
Inverse tangent, element-wise.
74
75
Parameters:
76
- x: array-like
77
- out: ndarray, optional output array
78
79
Returns:
80
cupy.ndarray, angles in radians in [-pi/2, pi/2]
81
"""
82
83
def arctan2(y, x, out=None, **kwargs):
84
"""
85
Element-wise arc tangent of y/x choosing quadrant correctly.
86
87
Parameters:
88
- y: array-like, y-coordinates
89
- x: array-like, x-coordinates
90
- out: ndarray, optional output array
91
92
Returns:
93
cupy.ndarray, angles in radians in [-pi, pi]
94
"""
95
96
def degrees(x, out=None, **kwargs):
97
"""
98
Convert angles from radians to degrees.
99
100
Parameters:
101
- x: array-like, angles in radians
102
- out: ndarray, optional output array
103
104
Returns:
105
cupy.ndarray, angles in degrees
106
"""
107
108
def radians(x, out=None, **kwargs):
109
"""
110
Convert angles from degrees to radians.
111
112
Parameters:
113
- x: array-like, angles in degrees
114
- out: ndarray, optional output array
115
116
Returns:
117
cupy.ndarray, angles in radians
118
"""
119
120
def hypot(x1, x2, out=None, **kwargs):
121
"""
122
Given two sides of right triangle, return hypotenuse.
123
124
Parameters:
125
- x1, x2: array-like, sides of triangle
126
- out: ndarray, optional output array
127
128
Returns:
129
cupy.ndarray, hypotenuse sqrt(x1**2 + x2**2)
130
"""
131
```
132
133
### Hyperbolic Functions
134
135
Hyperbolic functions for mathematical computations.
136
137
```python { .api }
138
def sinh(x, out=None, **kwargs):
139
"""
140
Hyperbolic sine, element-wise.
141
142
Parameters:
143
- x: array-like
144
- out: ndarray, optional output array
145
146
Returns:
147
cupy.ndarray
148
"""
149
150
def cosh(x, out=None, **kwargs):
151
"""
152
Hyperbolic cosine, element-wise.
153
154
Parameters:
155
- x: array-like
156
- out: ndarray, optional output array
157
158
Returns:
159
cupy.ndarray
160
"""
161
162
def tanh(x, out=None, **kwargs):
163
"""
164
Hyperbolic tangent, element-wise.
165
166
Parameters:
167
- x: array-like
168
- out: ndarray, optional output array
169
170
Returns:
171
cupy.ndarray
172
"""
173
174
def arcsinh(x, out=None, **kwargs):
175
"""
176
Inverse hyperbolic sine, element-wise.
177
178
Parameters:
179
- x: array-like
180
- out: ndarray, optional output array
181
182
Returns:
183
cupy.ndarray
184
"""
185
186
def arccosh(x, out=None, **kwargs):
187
"""
188
Inverse hyperbolic cosine, element-wise.
189
190
Parameters:
191
- x: array-like, values >= 1
192
- out: ndarray, optional output array
193
194
Returns:
195
cupy.ndarray
196
"""
197
198
def arctanh(x, out=None, **kwargs):
199
"""
200
Inverse hyperbolic tangent, element-wise.
201
202
Parameters:
203
- x: array-like, values in (-1, 1)
204
- out: ndarray, optional output array
205
206
Returns:
207
cupy.ndarray
208
"""
209
```
210
211
### Exponential and Logarithmic Functions
212
213
Functions for exponential and logarithmic operations.
214
215
```python { .api }
216
def exp(x, out=None, **kwargs):
217
"""
218
Calculate exponential of all elements.
219
220
Parameters:
221
- x: array-like
222
- out: ndarray, optional output array
223
224
Returns:
225
cupy.ndarray, e**x
226
"""
227
228
def exp2(x, out=None, **kwargs):
229
"""
230
Calculate 2**x for all elements.
231
232
Parameters:
233
- x: array-like
234
- out: ndarray, optional output array
235
236
Returns:
237
cupy.ndarray, 2**x
238
"""
239
240
def expm1(x, out=None, **kwargs):
241
"""
242
Calculate exp(x) - 1 for all elements.
243
244
Parameters:
245
- x: array-like
246
- out: ndarray, optional output array
247
248
Returns:
249
cupy.ndarray, exp(x) - 1
250
"""
251
252
def log(x, out=None, **kwargs):
253
"""
254
Natural logarithm, element-wise.
255
256
Parameters:
257
- x: array-like
258
- out: ndarray, optional output array
259
260
Returns:
261
cupy.ndarray, ln(x)
262
"""
263
264
def log10(x, out=None, **kwargs):
265
"""
266
Base-10 logarithm, element-wise.
267
268
Parameters:
269
- x: array-like
270
- out: ndarray, optional output array
271
272
Returns:
273
cupy.ndarray, log10(x)
274
"""
275
276
def log2(x, out=None, **kwargs):
277
"""
278
Base-2 logarithm, element-wise.
279
280
Parameters:
281
- x: array-like
282
- out: ndarray, optional output array
283
284
Returns:
285
cupy.ndarray, log2(x)
286
"""
287
288
def log1p(x, out=None, **kwargs):
289
"""
290
Calculate log(1 + x) for all elements.
291
292
Parameters:
293
- x: array-like
294
- out: ndarray, optional output array
295
296
Returns:
297
cupy.ndarray, log(1 + x)
298
"""
299
300
def logaddexp(x1, x2, out=None, **kwargs):
301
"""
302
Logarithm of sum of exponentials of inputs.
303
304
Parameters:
305
- x1, x2: array-like
306
- out: ndarray, optional output array
307
308
Returns:
309
cupy.ndarray, log(exp(x1) + exp(x2))
310
"""
311
```
312
313
### Arithmetic Operations
314
315
Basic arithmetic operations for element-wise computation.
316
317
```python { .api }
318
def add(x1, x2, out=None, **kwargs):
319
"""
320
Add arguments element-wise.
321
322
Parameters:
323
- x1, x2: array-like
324
- out: ndarray, optional output array
325
326
Returns:
327
cupy.ndarray, x1 + x2
328
"""
329
330
def subtract(x1, x2, out=None, **kwargs):
331
"""
332
Subtract arguments element-wise.
333
334
Parameters:
335
- x1, x2: array-like
336
- out: ndarray, optional output array
337
338
Returns:
339
cupy.ndarray, x1 - x2
340
"""
341
342
def multiply(x1, x2, out=None, **kwargs):
343
"""
344
Multiply arguments element-wise.
345
346
Parameters:
347
- x1, x2: array-like
348
- out: ndarray, optional output array
349
350
Returns:
351
cupy.ndarray, x1 * x2
352
"""
353
354
def divide(x1, x2, out=None, **kwargs):
355
"""
356
Divide arguments element-wise.
357
358
Parameters:
359
- x1, x2: array-like
360
- out: ndarray, optional output array
361
362
Returns:
363
cupy.ndarray, x1 / x2
364
"""
365
366
def true_divide(x1, x2, out=None, **kwargs):
367
"""
368
True division element-wise.
369
370
Parameters:
371
- x1, x2: array-like
372
- out: ndarray, optional output array
373
374
Returns:
375
cupy.ndarray, x1 / x2 with true division
376
"""
377
378
def floor_divide(x1, x2, out=None, **kwargs):
379
"""
380
Floor division element-wise.
381
382
Parameters:
383
- x1, x2: array-like
384
- out: ndarray, optional output array
385
386
Returns:
387
cupy.ndarray, floor(x1 / x2)
388
"""
389
390
def power(x1, x2, out=None, **kwargs):
391
"""
392
First array elements raised to powers from second array.
393
394
Parameters:
395
- x1: array-like, base
396
- x2: array-like, exponent
397
- out: ndarray, optional output array
398
399
Returns:
400
cupy.ndarray, x1**x2
401
"""
402
403
def sqrt(x, out=None, **kwargs):
404
"""
405
Return non-negative square root element-wise.
406
407
Parameters:
408
- x: array-like
409
- out: ndarray, optional output array
410
411
Returns:
412
cupy.ndarray, sqrt(x)
413
"""
414
415
def square(x, out=None, **kwargs):
416
"""
417
Return element-wise square of input.
418
419
Parameters:
420
- x: array-like
421
- out: ndarray, optional output array
422
423
Returns:
424
cupy.ndarray, x**2
425
"""
426
427
def absolute(x, out=None, **kwargs):
428
"""
429
Calculate absolute value element-wise.
430
431
Parameters:
432
- x: array-like
433
- out: ndarray, optional output array
434
435
Returns:
436
cupy.ndarray, |x|
437
"""
438
439
def sign(x, out=None, **kwargs):
440
"""
441
Returns element-wise indication of sign of number.
442
443
Parameters:
444
- x: array-like
445
- out: ndarray, optional output array
446
447
Returns:
448
cupy.ndarray, -1, 0, or 1 indicating sign
449
"""
450
```
451
452
### Rounding Functions
453
454
Functions for rounding and truncating values.
455
456
```python { .api }
457
def around(a, decimals=0, out=None):
458
"""
459
Round array to given number of decimals.
460
461
Parameters:
462
- a: array-like
463
- decimals: int, number of decimal places
464
- out: ndarray, optional output array
465
466
Returns:
467
cupy.ndarray
468
"""
469
470
def ceil(x, out=None, **kwargs):
471
"""
472
Return ceiling of input, element-wise.
473
474
Parameters:
475
- x: array-like
476
- out: ndarray, optional output array
477
478
Returns:
479
cupy.ndarray, ceiling values
480
"""
481
482
def floor(x, out=None, **kwargs):
483
"""
484
Return floor of input, element-wise.
485
486
Parameters:
487
- x: array-like
488
- out: ndarray, optional output array
489
490
Returns:
491
cupy.ndarray, floor values
492
"""
493
494
def trunc(x, out=None, **kwargs):
495
"""
496
Return truncated value of input, element-wise.
497
498
Parameters:
499
- x: array-like
500
- out: ndarray, optional output array
501
502
Returns:
503
cupy.ndarray, truncated values
504
"""
505
506
def rint(x, out=None, **kwargs):
507
"""
508
Round elements to nearest integers.
509
510
Parameters:
511
- x: array-like
512
- out: ndarray, optional output array
513
514
Returns:
515
cupy.ndarray, rounded integers
516
"""
517
```
518
519
### Reduction Operations
520
521
Operations that reduce arrays along specified axes.
522
523
```python { .api }
524
def sum(a, axis=None, dtype=None, out=None, keepdims=False):
525
"""
526
Sum of array elements over given axis.
527
528
Parameters:
529
- a: array-like
530
- axis: int or tuple of ints, axis to sum along
531
- dtype: data type of output
532
- out: ndarray, optional output array
533
- keepdims: bool, keep reduced dimensions
534
535
Returns:
536
cupy.ndarray, sum along axis
537
"""
538
539
def prod(a, axis=None, dtype=None, out=None, keepdims=False):
540
"""
541
Product of array elements over given axis.
542
543
Parameters:
544
- a: array-like
545
- axis: int or tuple of ints, axis to multiply along
546
- dtype: data type of output
547
- out: ndarray, optional output array
548
- keepdims: bool, keep reduced dimensions
549
550
Returns:
551
cupy.ndarray, product along axis
552
"""
553
554
def mean(a, axis=None, dtype=None, out=None, keepdims=False):
555
"""
556
Arithmetic mean along specified axis.
557
558
Parameters:
559
- a: array-like
560
- axis: int or tuple of ints, axis to average along
561
- dtype: data type of output
562
- out: ndarray, optional output array
563
- keepdims: bool, keep reduced dimensions
564
565
Returns:
566
cupy.ndarray, mean along axis
567
"""
568
569
def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
570
"""
571
Variance along specified axis.
572
573
Parameters:
574
- a: array-like
575
- axis: int or tuple of ints, axis to compute variance along
576
- dtype: data type of output
577
- out: ndarray, optional output array
578
- ddof: int, delta degrees of freedom
579
- keepdims: bool, keep reduced dimensions
580
581
Returns:
582
cupy.ndarray, variance along axis
583
"""
584
585
def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
586
"""
587
Standard deviation along specified axis.
588
589
Parameters:
590
- a: array-like
591
- axis: int or tuple of ints, axis to compute std along
592
- dtype: data type of output
593
- out: ndarray, optional output array
594
- ddof: int, delta degrees of freedom
595
- keepdims: bool, keep reduced dimensions
596
597
Returns:
598
cupy.ndarray, standard deviation along axis
599
"""
600
601
def cumsum(a, axis=None, dtype=None, out=None):
602
"""
603
Cumulative sum along given axis.
604
605
Parameters:
606
- a: array-like
607
- axis: int, axis to compute cumsum along
608
- dtype: data type of output
609
- out: ndarray, optional output array
610
611
Returns:
612
cupy.ndarray, cumulative sum
613
"""
614
615
def cumprod(a, axis=None, dtype=None, out=None):
616
"""
617
Cumulative product along given axis.
618
619
Parameters:
620
- a: array-like
621
- axis: int, axis to compute cumulative product along
622
- dtype: data type of output
623
- out: ndarray, optional output array
624
625
Returns:
626
cupy.ndarray, cumulative product
627
"""
628
```
629
630
### Extrema Finding
631
632
Functions for finding minimum and maximum values.
633
634
```python { .api }
635
def amax(a, axis=None, out=None, keepdims=False, initial=None, where=None):
636
"""
637
Maximum of array elements along given axis.
638
639
Parameters:
640
- a: array-like
641
- axis: int or tuple of ints, axis to find max along
642
- out: ndarray, optional output array
643
- keepdims: bool, keep reduced dimensions
644
- initial: scalar, initial value for comparison
645
- where: array of bool, elements to include
646
647
Returns:
648
cupy.ndarray, maximum values
649
"""
650
651
def amin(a, axis=None, out=None, keepdims=False, initial=None, where=None):
652
"""
653
Minimum of array elements along given axis.
654
655
Parameters:
656
- a: array-like
657
- axis: int or tuple of ints, axis to find min along
658
- out: ndarray, optional output array
659
- keepdims: bool, keep reduced dimensions
660
- initial: scalar, initial value for comparison
661
- where: array of bool, elements to include
662
663
Returns:
664
cupy.ndarray, minimum values
665
"""
666
667
def maximum(x1, x2, out=None, **kwargs):
668
"""
669
Element-wise maximum of array elements.
670
671
Parameters:
672
- x1, x2: array-like
673
- out: ndarray, optional output array
674
675
Returns:
676
cupy.ndarray, element-wise maximum
677
"""
678
679
def minimum(x1, x2, out=None, **kwargs):
680
"""
681
Element-wise minimum of array elements.
682
683
Parameters:
684
- x1, x2: array-like
685
- out: ndarray, optional output array
686
687
Returns:
688
cupy.ndarray, element-wise minimum
689
"""
690
691
def clip(a, a_min, a_max, out=None, **kwargs):
692
"""
693
Clip values in array to given range.
694
695
Parameters:
696
- a: array-like
697
- a_min: scalar or array, minimum value
698
- a_max: scalar or array, maximum value
699
- out: ndarray, optional output array
700
701
Returns:
702
cupy.ndarray, clipped values
703
"""
704
```
705
706
## Usage Examples
707
708
### Basic Mathematical Operations
709
710
```python
711
import cupy as cp
712
713
# Create test data
714
x = cp.linspace(0, 2 * cp.pi, 100)
715
y = cp.array([1, 2, 3, 4, 5])
716
717
# Trigonometric functions
718
sin_values = cp.sin(x)
719
cos_values = cp.cos(x)
720
tan_values = cp.tan(x)
721
722
# Exponential and logarithmic
723
exp_values = cp.exp(y)
724
log_values = cp.log(y)
725
726
# Element-wise arithmetic
727
z = cp.add(y, 10)
728
product = cp.multiply(y, y)
729
power_values = cp.power(y, 2)
730
```
731
732
### Statistical Operations
733
734
```python
735
import cupy as cp
736
737
# Create sample data
738
data = cp.random.random((1000, 100))
739
740
# Statistical measures
741
mean_val = cp.mean(data, axis=0)
742
std_val = cp.std(data, axis=0)
743
var_val = cp.var(data, axis=1)
744
745
# Extrema
746
max_vals = cp.amax(data, axis=1)
747
min_vals = cp.amin(data, axis=1)
748
749
# Cumulative operations
750
cumulative_sum = cp.cumsum(data, axis=0)
751
running_product = cp.cumprod(data[:10, 0])
752
```
753
754
### Advanced Mathematical Operations
755
756
```python
757
import cupy as cp
758
759
# Complex mathematical operations
760
angles = cp.linspace(0, 2*cp.pi, 1000)
761
complex_signal = cp.exp(1j * angles)
762
763
# Real and imaginary parts
764
real_part = cp.real(complex_signal)
765
imag_part = cp.imag(complex_signal)
766
magnitude = cp.absolute(complex_signal)
767
768
# Hyperbolic functions
769
x = cp.linspace(-2, 2, 100)
770
sinh_vals = cp.sinh(x)
771
tanh_vals = cp.tanh(x)
772
773
# Special operations
774
clipped = cp.clip(x, -1, 1)
775
rounded = cp.around(x, decimals=2)
776
```