little small major update

cpp_programs/multi_linear_sequences/Makefile

@@ -1,27 +1,22 @@
 .DEFAULT_GOAL := all
 
 CC=g++
-CFLAGS=-Werror -Wall -std=c++20 -pthread -O3
-# CFLAGS=-Werror -Wall -std=c++20 -O2 -pthread -fmodules-ts
+OPTIMIZATION=-O2
+# CFLAGS=-Werror -Wall -std=c++20 -pthread -O3
+CFLAGS=-Werror -Wall -std=c++20 $(OPTIMIZATION) -pthread -fmodules-ts
 # CFLAGS=-Wall -std=c++20
 
 iostream:
 	$(CC) $(CFLAGS) -x c++-system-header iostream -c
-utils: utils.cpp
+utils.o: utils.cpp utils.h
 	$(CC) $(CFLAGS) utils.cpp -c
-# thread_data_generic: utils utils.o thread_data_generic.cppm
-# 	$(CC) $(CFLAGS) thread_data_generic.cppm -c
-thread_data_generic: utils utils.o thread_data_generic.cpp
+thread_data_generic.o: thread_data_generic.cpp thread_data_generic.h
 	$(CC) $(CFLAGS) thread_data_generic.cpp -c
-multi_linear_sequences: utils utils.o thread_data_generic thread_data_generic.o multi_linear_sequences.cpp
+multi_linear_sequences.o: multi_linear_sequences.cpp multi_linear_sequences.h
 	$(CC) $(CFLAGS) multi_linear_sequences.cpp -c
-main: main.cpp
-main: utils utils.o thread_data_generic thread_data_generic.o multi_linear_sequences multi_linear_sequences.o main.cpp
+main.o: utils.o thread_data_generic.o multi_linear_sequences.o main.cpp
 	$(CC) $(CFLAGS) utils.o thread_data_generic.o multi_linear_sequences.o main.cpp -o main.o
-#	$(CC) $(CFLAGS) utils.cpp multi_linear_sequences.cpp main.cpp -o main.o
-# 	$(CC) $(CFLAGS) utils.cpp thread_data_generic.cpp multi_linear_sequences.cpp main.cpp -o main.o
-# 	$(CC) $(CFLAGS) utils.o thread_data_generic.o multi_linear_sequences.o main.cpp -o main.o
-all: main
+all: main.o
 
 clean:
 	rm utils.o

math_numbers/prime_numbers_fun.py

@@ -42,22 +42,26 @@ def get_primes(n):
 
 
 def prime_factorization(n, ps):
-    lst = []
+    # lst = []
+    d = {}
 
     for p in ps:
         count = 0
         while n%p==0:
             count += 1
             n //= p
-        lst.append((p, count))
+        if count > 0:
+            d[p] = count
+        # lst.append((p, count))
         if n==1:
             break
 
-    return lst
+    # return lst
+    return d
 
 
 def get_prime_amount_timetable(n, ps):
-    timetable = np.zeros((len(ps), )).astype(np.int)
+    timetable = np.zeros((len(ps), )).astype(np.int64)
 
     for i, p in enumerate(ps):
         t = n//p

math_riddles/floor_problem_challenge.py

@@ -20,7 +20,7 @@ def f(x):
         fl_y = fl(y)
         print("numer: {}, denom: {}, float(y): {}".format(numer, denom, float(y)))
 
-        if y.numerator%y.denominator==0 and fl_y==n:
+        if (y.numerator % y.denominator == 0) and (fl_y == n):
             break
 
         if is_increment_numerator:

modulo_sequences/matrix_multi_linear_sequences.py

@@ -78,85 +78,107 @@ def get_num_from_base_lst(l, b):
     # print('Hello World!')
     argv = sys.argv
     n = int(argv[1])
-    m = int(argv[2])
-
-    MAX_CYCLE_LEN = m**n
-
-    def get_missing_tpl_a(d_tpl_a):
-        s_all = set(range(0, MAX_CYCLE_LEN))
-        for k in d_tpl_a:
-            s_all.remove(get_num_from_base_lst(l=k, b=m))
-        missing_n = list(s_all)[0]
-        # print("- missing_n: {}".format(missing_n))
-        l_a_missing = convert_num_to_base_num(n=missing_n, b=m, min_len=n)
-        tpl_a_missing = tuple(l_a_missing)
-        assert tpl_a_missing not in d_tpl_a
-        return tpl_a_missing
-
-    # s_cycle_len = set()
-    d_cycle_len = {}
-    for iters in range(0, 100000):
-        if iters % 1000 == 0:
-            print("iters: {}".format(iters))
-
-        arr_a = np.random.randint(0, m, (n, ))
-        arr_v_k = np.random.randint(0, m, (n, ))
-        arr_m_k = np.random.randint(0, m, (n, n))
-
-        l_a = arr_a.tolist()
-
-        tpl_a = tuple(arr_a.tolist())
-        tpl_a_prev = tpl_a
-        d_tpl_a = {tpl_a: 0}
-        nr_tpl_a = 1
-        while True:
-            arr_a[:] = (arr_v_k + arr_m_k.dot(arr_a)) % m
-            tpl_a_prev = tpl_a
+    # m = int(argv[2])
+
+    d_m_to_cycle_len = {}
+    for m in range(1, 11):
+        MAX_CYCLE_LEN = m**n
+
+        def get_missing_tpl_a(d_tpl_a):
+            s_all = set(range(0, MAX_CYCLE_LEN))
+            for k in d_tpl_a:
+                s_all.remove(get_num_from_base_lst(l=k, b=m))
+            missing_n = list(s_all)[0]
+            # print("- missing_n: {}".format(missing_n))
+            l_a_missing = convert_num_to_base_num(n=missing_n, b=m, min_len=n)
+            tpl_a_missing = tuple(l_a_missing)
+            assert tpl_a_missing not in d_tpl_a
+            return tpl_a_missing
+
+        # s_cycle_len = set()
+        d_cycle_len = {}
+        for iters in range(0, 20000):
+            if iters % 1000 == 0:
+                print(f"m: {m}, iters: {iters}")
+
+            arr_a = np.random.randint(0, m, (n, ))
+            arr_v_k = np.random.randint(0, m, (n, ))
+            arr_m_k = np.random.randint(0, m, (n, ))
+            # arr_m_k = np.random.randint(0, m, (n, n))
+
+            l_a = arr_a.tolist()
+
             tpl_a = tuple(arr_a.tolist())
+            tpl_a_prev = tpl_a
+            d_tpl_a = {tpl_a: 0}
+            nr_tpl_a = 1
+            while True:
+                a_next = np.sum((arr_v_k + arr_m_k * arr_a) % m) % m
+                arr_a[:-1] = arr_a[1:]
+                arr_a[-1] = a_next
+
+                # arr_a[:] = np.roll((arr_v_k + arr_m_k * arr_a) % m, 1)
+
+                # arr_a[:] = (arr_v_k + arr_m_k * arr_a) % m
+
+                tpl_a_prev = tpl_a
+                tpl_a = tuple(arr_a.tolist())
+
+                if tpl_a in d_tpl_a:
+                    break
+
+                d_tpl_a[tpl_a] = nr_tpl_a
+                nr_tpl_a += 1
 
-            if tpl_a in d_tpl_a:
-                break
-
-            d_tpl_a[tpl_a] = nr_tpl_a
-            nr_tpl_a += 1
-
-        cycle_len = d_tpl_a[tpl_a_prev] - d_tpl_a[tpl_a] + 1
-        if cycle_len not in d_cycle_len:
-            d_cycle_len[cycle_len] = {
-                'l_v_k': arr_v_k.tolist(),
-                'l_m_k': arr_m_k.tolist(),
-                'l_a': l_a,
-                'd_tpl_a': d_tpl_a,
-                'tpl_a': tpl_a,
-                'tpl_a_prev': tpl_a_prev,
-            }
-        elif cycle_len == MAX_CYCLE_LEN - 1:
-            d = d_cycle_len[cycle_len]
-            if 'missing_tpl_a' not in d:
-                d['missing_tpl_a'] = get_missing_tpl_a(d_tpl_a=d['d_tpl_a'])
-                # print("d['missing_tpl_a']: {}".format(d['missing_tpl_a']))
-            else:
-                missing_tpl_a = get_missing_tpl_a(d_tpl_a=d_tpl_a)
-                # print("maybe? missing_tpl_a: {}".format(missing_tpl_a))
-                l11 = list(reversed(d['missing_tpl_a']))
-                l12 = list(reversed(missing_tpl_a))
-
-                l21 = d['l_v_k']
-                l22 = arr_v_k.tolist()
-                if l11 > l12 or l11 == l12 and \
-                (l21 > l22 or l21 == l22 and sorted(d['l_m_k']) > sorted(arr_m_k.tolist())):
-                    d['l_v_k'] = arr_v_k.tolist()
-                    d['l_m_k'] = arr_m_k.tolist()
-                    d['l_a'] = l_a
-                    d['d_tpl_a'] = d_tpl_a
-                    d['tpl_a'] = tpl_a
-                    d['tpl_a_prev'] = tpl_a_prev
-                    d['missing_tpl_a'] = missing_tpl_a
+            cycle_len = d_tpl_a[tpl_a_prev] - d_tpl_a[tpl_a] + 1
+            if cycle_len not in d_cycle_len:
+                d_cycle_len[cycle_len] = {
+                    'l_v_k': arr_v_k.tolist(),
+                    'l_m_k': arr_m_k.tolist(),
+                    'l_a': l_a,
+                    'd_tpl_a': d_tpl_a,
+                    'tpl_a': tpl_a,
+                    'tpl_a_prev': tpl_a_prev,
+                }
+            elif cycle_len == MAX_CYCLE_LEN - 1 and n > 1:
+                d = d_cycle_len[cycle_len]
+                if 'missing_tpl_a' not in d:
+                    d['missing_tpl_a'] = get_missing_tpl_a(d_tpl_a=d['d_tpl_a'])
                     # print("d['missing_tpl_a']: {}".format(d['missing_tpl_a']))
-        # d_cycle_len[cycle_len] += 1
-
-    l_cycle_len = sorted(d_cycle_len.keys())
-    max_cycle_len = l_cycle_len[-1]
-    print(f"n: {n}, m: {m}, l_cycle_len: {l_cycle_len}")
-
-    print(f"d_cycle_len[{max_cycle_len}]: {d_cycle_len[max_cycle_len]}")
+                else:
+                    missing_tpl_a = get_missing_tpl_a(d_tpl_a=d_tpl_a)
+                    # print("maybe? missing_tpl_a: {}".format(missing_tpl_a))
+                    l11 = list(reversed(d['missing_tpl_a']))
+                    l12 = list(reversed(missing_tpl_a))
+
+                    l21 = d['l_v_k']
+                    l22 = arr_v_k.tolist()
+                    if l11 > l12 or l11 == l12 and \
+                    (l21 > l22 or l21 == l22 and sorted(d['l_m_k']) > sorted(arr_m_k.tolist())):
+                        d['l_v_k'] = arr_v_k.tolist()
+                        d['l_m_k'] = arr_m_k.tolist()
+                        d['l_a'] = l_a
+                        d['d_tpl_a'] = d_tpl_a
+                        d['tpl_a'] = tpl_a
+                        d['tpl_a_prev'] = tpl_a_prev
+                        d['missing_tpl_a'] = missing_tpl_a
+                        # print("d['missing_tpl_a']: {}".format(d['missing_tpl_a']))
+            # d_cycle_len[cycle_len] += 1
+
+        l_cycle_len = sorted(d_cycle_len.keys())
+        max_cycle_len = l_cycle_len[-1]
+        print(f"n: {n}, m: {m}, l_cycle_len: {l_cycle_len}")
+
+        d = d_cycle_len[max_cycle_len]
+        print(f"d_cycle_len[{max_cycle_len}]: {d_cycle_len[max_cycle_len]}")
+        print(f"n: {n}, m: {m}")
+        print(f"d['l_v_k']: {d['l_v_k']}")
+        print(f"d['l_m_k']: {d['l_m_k']}")
+
+        d_m_to_cycle_len[m] = max_cycle_len
+
+    print(f"d_m_to_cycle_len: {d_m_to_cycle_len}")
+
+    print(f"n: {n}")
+    l_vals = [v for _, v in sorted(d_m_to_cycle_len.items())]
+    print(f"l_vals: {l_vals}")

test_programs/test.yml

@@ -0,0 +1,7 @@
+a:
+  b:
+    c:
+      test: 5
+  d:
+    - 5=4
+    - 3: 6

test_programs/test_read_yml_file.py

@@ -0,0 +1,8 @@
+#! /usr/bin/python3.9
+
+import yaml
+
+with open('test.yml') as f:
+    yml_content = yaml.load(f, Loader=yaml.FullLoader)
+
+print(yml_content)

utils/utils_csv.py

@@ -0,0 +1,17 @@
+import numpy as np
+import pandas as pd
+
+from typing import Tuple, List, Any
+
+def get_csv_lines_as_df(file_path: str) -> pd.DataFrame:
+    with open(file_path, 'r') as f:
+        content = f.read()
+
+    l_line = content.split('\n')
+    df_line = pd.DataFrame(
+        data=[(i, line) for i, line in enumerate(l_line, 1)],
+        columns=['line_nr', 'line'],
+        dtype=object,
+    )
+
+    return df_line

utils/utils_df.py

@@ -0,0 +1,23 @@
+import numpy as np
+import pandas as pd
+
+from typing import Tuple, List, Any
+
+def check_df_index(df: pd.DataFrame) -> None:
+    assert df.index.values[0] == 0
+    assert np.all(np.diff(df.index.values) == 1)
+
+def get_df_part_loc(
+    df: pd.DataFrame,
+    l_column_l_values: List[Tuple[str, List[Any]]],
+) -> Tuple[np.ndarray, pd.DataFrame, pd.DataFrame]:
+    if len(l_column_l_values) == 0:
+        arr_idx_bool = np.ones((df.shape[0], ), dtype=np.bool)
+        return np.df
+
+    column_name, l_values = l_column_l_values[0]
+    arr_idx_bool = np.isin(df[column_name].values, l_values)
+    for column_name, l_values in l_column_l_values[1:]:
+        arr_idx_bool &= np.isin(df[column_name].values, l_values)
+
+    return arr_idx_bool, df.loc[arr_idx_bool], df.loc[~arr_idx_bool]