NumPy Math Functions

In [2]:
import numpy as np
In [3]:
arr = np.random.randint(10,99,[3,3])
arr
Out[3]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])

Element-wise addition, subtraction, multiplication and division

In [4]:
print(arr + 10)
print(arr - 10)
print(arr * 10)
print(arr / 10)

[[55 63 88]
 [91 98 35]
 [81 65 69]]
[[35 43 68]
 [71 78 15]
 [61 45 49]]
[[450 530 780]
 [810 880 250]
 [710 550 590]]
[[4.5 5.3 7.8]
 [8.1 8.8 2.5]
 [7.1 5.5 5.9]]
In [5]:
# the above operations can be performed using numpy built-in functions
# which can save memory as the output can be stored in the original array rather than assigning new memory
arr1 = np.array([1,2,3])
np.add(arr1, [8,9,10], out=arr1)
print(arr1)

np.subtract(arr1, [8,9,10], out=arr1)
print(arr1)

np.multiply(arr1, [1,2,3], out=arr1)
print(arr1)

[ 9 11 13]
[1 2 3]
[1 4 9]

Element-wise exponentiation

In [6]:
print(np.exp(arr))

[[3.49342711e+19 1.04137594e+23 7.49841700e+33]
 [1.50609731e+35 1.65163625e+38 7.20048993e+10]
 [6.83767123e+30 7.69478527e+23 4.20121040e+25]]

Element-wise logorithm

In [7]:
# natural log
print(np.log(arr))      

[[3.80666249 3.97029191 4.35670883]
 [4.39444915 4.47733681 3.21887582]
 [4.26267988 4.00733319 4.07753744]]
In [8]:
# base 2
print(np.log2(arr))     

[[5.4918531  5.72792045 6.28540222]
 [6.33985    6.45943162 4.64385619]
 [6.14974712 5.78135971 5.88264305]]
In [9]:
# base 10
print(np.log10(arr))    

[[1.65321251 1.72427587 1.8920946 ]
 [1.90848502 1.94448267 1.39794001]
 [1.85125835 1.74036269 1.77085201]]

Element-wise square root

In [10]:
print(np.sqrt(arr))

[[6.70820393 7.28010989 8.83176087]
 [9.         9.38083152 5.        ]
 [8.42614977 7.41619849 7.68114575]]

Element-wise sine and cosine

In [11]:
print(np.sin(arr))

[[ 0.85090352  0.39592515  0.51397846]
 [-0.62988799  0.0353983  -0.13235175]
 [ 0.95105465 -0.99975517  0.63673801]]
In [12]:
print(np.cos(arr))

[[ 0.52532199 -0.91828279 -0.85780309]
 [ 0.77668598  0.99937328  0.99120281]
 [-0.30902273  0.02212676 -0.77108022]]

Sum along a specified axis

In [13]:
arr
Out[13]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])
In [14]:
# sum along the row
print(np.sum(arr, axis=0))    

[197 196 162]
In [15]:
# sum along the column
print(np.sum(arr, axis=1))    

[176 194 185]

Compute the min and max along a specified axis

In [16]:
arr
Out[16]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])
In [17]:
# calculate min along the row
print(np.min(arr, axis=0))

[45 53 25]
In [18]:
# calculate max along the column
print(np.max(arr, axis=1))    

[78 88 71]
In [19]:
# if axis not specified, calculate the max/min value of all elements
print(np.max(arr))
print(np.min(arr))

88
25

Compute the indices of the min and max along a specified axis

In [20]:
arr
Out[20]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])
In [21]:
# along the row
print(np.argmin(arr, axis=0))
print(np.argmax(arr, axis=0))

[0 0 1]
[1 1 0]
In [22]:
# along the column
print(np.argmin(arr, axis=1))
print(np.argmax(arr, axis=1))

[0 2 1]
[2 1 0]
In [23]:
# if axis not specified, return the index of the flattened array
print(np.argmin(arr))
print(np.argmax(arr))

5
4

Compute element-wise min and max of two arrays

In [24]:
arr1 = np.array([1, 3, 5, 7, 9])
arr2 = np.array([0, 4, 3, 8, 7])
print(np.maximum(arr1, arr2))
print(np.minimum(arr1, arr2))

[1 4 5 8 9]
[0 3 3 7 7]

Split fractional and integral parts of a floating-point array

In [25]:
arr1 = np.random.rand(10) * 10
re, intg = np.modf(arr1)
print('fractional: ', re)
print('integral: ', intg)

fractional:  [0.61238088 0.49277372 0.7488407  0.51805791 0.24094172 0.57935203
 0.97274589 0.34999626 0.85337645 0.4998429 ]
integral:  [4. 6. 3. 9. 5. 7. 8. 3. 2. 2.]

Compute the mean

In [26]:
arr
Out[26]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])
In [27]:
# compute the overall mean
print(np.mean(arr))

61.666666666666664
In [28]:
# compute the mean along the row
print(np.mean(arr, axis=0))   

[65.66666667 65.33333333 54.        ]
In [29]:
# compute the mean along the column
print(np.mean(arr, axis=1)) 

[58.66666667 64.66666667 61.66666667]

Compute the median

In [30]:
arr
Out[30]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])
In [31]:
# compute the overall median
print(np.median(arr))

59.0
In [32]:
# compute the median along the row
print(np.median(arr, axis=0)) 

[71. 55. 59.]
In [33]:
# compute the median along the column
print(np.median(arr, axis=1))

[53. 81. 59.]

Compute the percentile

In [34]:
arr1 = np.random.rand(100)
# compute 5, 65, and 95 percentiles of the array
print(np.percentile(arr1, [5, 65, 95]))

[0.04720134 0.59197879 0.93064323]

Compute the standard deviation & variance

In [35]:
arr
Out[35]:
array([[45, 53, 78],
       [81, 88, 25],
       [71, 55, 59]])
In [36]:
# compute the overall standard deviation
print(np.std(arr))

18.76758434701233
In [37]:
# compute the standard deviation along the row
print(np.std(arr, axis=0))

[15.17307557 16.04853749 21.92411154]
In [38]:
# compute the standard deviation along the column
print(np.std(arr, axis=1))

[14.05544576 28.19377394  6.79869268]
In [39]:
# compute the overall variance
print(np.var(arr))

352.22222222222223
In [40]:
# compute the variance along the row
print(np.var(arr, axis=0))

[230.22222222 257.55555556 480.66666667]
In [41]:
# compute the variance along the column
print(np.var(arr, axis=1))

[197.55555556 794.88888889  46.22222222]

Compute the covariance & correlation

In [42]:
arr = np.random.rand(5,8)
arr
Out[42]:
array([[0.95214752, 0.29493415, 0.05878789, 0.39374683, 0.71688838,
        0.05481   , 0.00623518, 0.07657365],
       [0.44869699, 0.38991553, 0.15028163, 0.25317292, 0.99921478,
        0.86781744, 0.28919635, 0.43225943],
       [0.24550552, 0.7726166 , 0.27018533, 0.68800599, 0.23574331,
        0.32689282, 0.65105567, 0.86009933],
       [0.23499775, 0.75088904, 0.84001736, 0.14851715, 0.52967944,
        0.66669622, 0.90208167, 0.0071426 ],
       [0.4463815 , 0.2661077 , 0.91024507, 0.76804913, 0.63738655,
        0.95655654, 0.4639961 , 0.96585732]])
In [43]:
print(np.cov(arr))

[[ 0.12277939  0.03236792 -0.0411153  -0.04672846 -0.04043407]
 [ 0.03236792  0.08970289 -0.03339385 -0.00281817  0.00876793]
 [-0.0411153  -0.03339385  0.06846022 -0.0231893  -0.00798352]
 [-0.04672846 -0.00281817 -0.0231893   0.11496709 -0.02531996]
 [-0.04043407  0.00876793 -0.00798352 -0.02531996  0.07046295]]
In [44]:
print(np.corrcoef(arr[:,0], arr[:,1]))

[[ 1.         -0.73159923]
 [-0.73159923  1.        ]]

Compute cumulative sum & product

In [45]:
# calculate the cumulative sums along the row
print(np.cumsum(arr, axis=0))    

[[0.95214752 0.29493415 0.05878789 0.39374683 0.71688838 0.05481
  0.00623518 0.07657365]
 [1.40084451 0.68484968 0.20906952 0.64691975 1.71610316 0.92262744
  0.29543152 0.50883308]
 [1.64635003 1.45746628 0.47925485 1.33492574 1.95184647 1.24952026
  0.94648719 1.36893241]
 [1.88134778 2.20835533 1.3192722  1.48344289 2.48152591 1.91621647
  1.84856886 1.37607501]
 [2.32772928 2.47446303 2.22951728 2.25149203 3.11891246 2.87277302
  2.31256496 2.34193234]]
In [46]:
# calculate the cumulative sums along the column
print(np.cumsum(arr, axis=1))    

[[0.95214752 1.24708168 1.30586957 1.6996164  2.41650477 2.47131477
  2.47754995 2.5541236 ]
 [0.44869699 0.83861252 0.98889414 1.24206707 2.24128185 3.10909929
  3.39829564 3.83055507]
 [0.24550552 1.01812212 1.28830745 1.97631344 2.21205675 2.53894956
  3.19000523 4.05010456]
 [0.23499775 0.98588679 1.82590415 1.9744213  2.50410074 3.17079696
  4.07287863 4.08002123]
 [0.4463815  0.7124892  1.62273427 2.39078341 3.02816996 3.9847265
  4.4487226  5.41457992]]
In [47]:
# calculate the cumulative product along the row
print(np.cumprod(arr, axis=0))   

[[9.52147523e-01 2.94934153e-01 5.87878910e-02 3.93746829e-01
  7.16888379e-01 5.48099993e-02 6.23517692e-03 7.65736508e-02]
 [4.27225725e-01 1.14999407e-01 8.83473992e-03 9.96860357e-02
  7.16325465e-01 4.75650733e-02 1.80319039e-03 3.30996827e-02]
 [1.04886274e-01 8.88504503e-02 2.38701711e-03 6.85845898e-02
  1.68868933e-01 1.55486808e-02 1.17397732e-03 2.84690148e-02]
 [2.46480383e-02 6.67168298e-02 2.00513580e-03 1.01859878e-02
  8.94464026e-02 1.03662466e-02 1.05902342e-03 2.03342908e-04]
 [1.10024283e-02 1.77538621e-02 1.82516499e-03 7.82333915e-03
  5.70119342e-02 9.91590108e-03 4.91382736e-04 1.96400237e-04]]
In [48]:
# calculate the cumulative product along the column
print(np.cumprod(arr, axis=1))  

[[9.52147523e-01 2.80820823e-01 1.65088639e-02 6.50031283e-03
  4.65999872e-03 2.55414527e-04 1.59255476e-06 1.21947732e-07]
 [4.48696987e-01 1.74953924e-01 2.62923604e-02 6.65651373e-03
  6.65128691e-03 5.77210279e-03 1.66927104e-03 7.21558150e-04]
 [2.45505521e-01 1.89681640e-01 5.12491965e-02 3.52597542e-02
  8.31225104e-03 2.71721515e-03 1.76905832e-03 1.52156587e-03]
 [2.34997748e-01 1.76457235e-01 1.48227140e-01 2.20142724e-02
  1.16605075e-02 7.77401628e-03 7.01279758e-03 5.00896384e-05]
 [4.46381498e-01 1.18785554e-01 1.08123965e-01 8.30445178e-02
  5.29314589e-02 5.06319334e-02 2.34930196e-02 2.26909050e-02]]

Element-wise comparison

In [49]:
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([5,4,3,2,1])
In [50]:
# return an array of bools
print(arr1 == arr2)    
print(arr1 < 3)

[False False  True False False]
[ True  True False False False]