Skip to main content

4 posts tagged with "Math"

View all tags

A simple solution to the problem of converting 0.248 (16) to a decimal fraction (Fundamental Information Technology Engineer Examination)

· One min read

Points​

Hexadecimal problems use binary.

Steps​

  1. Convert the hexadecimal number to binary. 0.248(16) = 0.0010 0100 1000(2)

  2. Remove the decimal point. 0.0010 0100 1000(2) = 0.0010 0100 1000(2) × 0010 0000 0000(2) / 0010 0000 0000(2) = 0100 1001(2) / 0010 0000 0000(2)

  3. Convert the binary number to decimal. 0100 1001(2) / 0010 0000 0000(2) = (64 + 8 + 1) / 512 = 73 / 512

Detecting extreme values ​​in Python

· 2 min read

Detecting extrema in a signal.​

Generating a spurious signal as an example.​

  • 3 [Hz] signal + 0.01 [Hz] signal + noise
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy import signal

tmp

Examining the properties of the signal.​

def acorr(df: pd.DataFrame, ra: int = 3, fs=100):
   x = np.correlate(df.Data.values, df.Data.values, mode='full')
   t = (np.arange(len(x)) - len(x) / 2 + 0.5) / fs
   x /= x.max()
   fig, ax = plt.subplots()
   ax.set_xlim(-ra, ra)
   ax.set_ylim(0, 1)
   ax.plot(t, x)
   ax.set_title('Autocorrelation')
   ax.grid(axis='x')
   ax.set_xticks(np.linspace(-ra, ra, 2 * ra + 1))
   plt.show()

acorr(df)

The main signal is 1/3 [Hz]. Therefore, a low-pass filter with a cutoff of 1/3 [Hz] is applied.

tmp

Applying a low-pass filter and detecting extrema.

If the extrema are not correctly detected even after applying a low-pass filter at 1/3 [Hz], the frequency is lowered.

tmp

fs = 10
lpf = 0.1
b, a = signal.butter(5, lpf / fs * 2, 'low')
df['Filter'] = signal.filtfilt(b, a, df.Data.values)
max_idx = signal.argrelextrema(df['Filter'].values, np.greater)[0]
min_idx = signal.argrelextrema(df['Filter'].values, np.less)[0]

df['max_index'] = False
df.iloc[max_idx[0], 2] = True
df['min_index'] = False
df.iloc[min_idx[0], 3] = True

fig, ax = plt.subplots()
df.plot(ax=ax)
ax.set_xlim(['00:00:00', '00:00:30'])
ax.scatter(
   df.loc[df['max_index'], ['Filter']].index, 
   df.loc[df['max_index'], ['Filter']], 
   color='tab:orange', 
   zorder=3)
ax.scatter(
   df.loc[df['min_index'], ['Filter']].index, 
   df.loc[df['min_index'], ['Filter']], 
   color='tab:green', 
   zorder=3)
plt.show()

Implementation of NMF (HALS)

· One min read
import numpy as np

X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])

n_components, n_samples, n_features, = (2,) + X.shape
W = np.random.uniform(size = (n_samples, n_components))
H = np.random.uniform(size = (n_components, n_features))

eps = 1e-4

# NMF
for i in range(100):
   # update B
   A = X.T.dot(W)
   B = W.T.dot(W)
   for j in range(n_components):
       tmp = H[j, :] + A[:, j] - H.T.dot(B[:, j])
       H[j, :] = np.maximum(tmp, eps)

   # update A
   C = X.dot(H.T)
   D = H.dot(H.T)
   for j in range(n_components):
       tmp = W[:, j] * D[j, j] + C[:, j] - W.dot(D[:, j])
       W[:, j] = np.maximum(tmp, eps)
       norm = np.linalg.norm(W[:, j])
       if norm > 0:
           W[:, j] /= norm

print(W)
print(H)
print(W.dot(H))

Euclidean Algorithm in Bash

· One min read

  1. Let C be the remainder when A is divided by B.

  2. Let D be the remainder when B is divided by C.

  3. Let E be the remainder when C is divided by D.

    ...

  4. Let Y be the remainder when X is divided by 0.

    Then Y is the greatest common divisor.

Bash Script

#!/usr/bin/env bash

function gcd(){
   test $2 -eq 0 && echo $1 || gcd $2 $(( $1 % $2 ))
}

gcd 1071 1029
# 21