from llvmlite import ir
import llvmlite.binding as llvm

import os


def create_global_string(builder: ir.IRBuilder, s: str, name: str) -> ir.Instruction:
    type_i8_x_len = ir.types.ArrayType(ir.types.IntType(8), len(s))
    value = ir.Constant(type_i8_x_len, bytearray(s.encode('utf-8')))

    variable = ir.GlobalVariable(builder.module, type_i8_x_len, name)
    variable.linkage = 'private'
    variable.unnamed_addr = True
    variable.global_constant = True
    variable.initializer = value
    variable.align = 1

    zero = ir.Constant(ir.types.IntType(32), 0)
    return variable.gep((zero, zero))


module = ir.Module(name="demo")

puts_type = ir.FunctionType(ir.IntType(32), (ir.IntType(8).as_pointer(),), var_arg=True)
puts_func = ir.Function(module, puts_type, "printf")

main_type = ir.FunctionType(ir.IntType(32), ())
main_func = ir.Function(module, main_type, "main")

block = main_func.append_basic_block(name="entry")
builder = ir.IRBuilder(block)
msg = create_global_string(builder, 'Hello,world!\n', "msg")

result = builder.call(puts_func, (msg,))
builder.ret(result)

print(module)

# generate bc
module_ref = llvm.parse_assembly(str(module))
module_ref.verify()
open("test03.bc", "wb").write(module_ref.as_bitcode())

# generate obj
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()

target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine(codemodel="small")

module.triple = llvm.get_default_triple()
module.data_layout = target_machine.target_data

obj = target_machine.emit_object(module_ref)
open('demo.o', 'wb').write(obj)

print("="*25, "execute", "="*25)
os.system("clang demo.o -o demo")
os.system("./demo")

import time
import signal

from IPython.terminal.embed import InteractiveShellEmbed
from IPython.core.autocall import ExitAutocall


class ExitCommand(ExitAutocall):
    def __call__(self):
        if "running" in self._ip.user_ns:
            self._ip.user_ns['running'] = False
        self._ip.ask_exit()


class CustomShell(InteractiveShellEmbed):
    def init_user_ns(self):
        super().init_user_ns()
        self.user_ns["exit"] = ExitCommand()


running = True
pause = False


def handler(signum, frame):
    global pause
    pause = True


signal.signal(signal.SIGINT, handler)

a = 0
while running:
    a += 1
    print(f"{a}")

    if pause:
        CustomShell().mainloop()
        pause = False

    time.sleep(1)

import numpy as np

# 给定一个原点、一个在坐标轴上的点和一个不在坐标轴上点，可以唯一的确定一个3维空间下的直角坐标系
O = np.array([1., 1., 1.])
X = np.array([2., 3., 4.])
P = np.array([2., 3., 5.])

# 1.确定x方向
x = X - O
x = x / np.linalg.norm(x)

# 2.确定y方向
p = P - O
y = p - np.dot(p, x) * x
y = y / np.linalg.norm(y)

# 3.确定z方向
z = np.cross(x, y)

# 4.验证
print(np.dot(x, y), np.dot(y, z), np.dot(z, x))
print(np.linalg.norm(x), np.linalg.norm(y), np.linalg.norm(z))

# 5.坐标变换：原空间->目标空间
S = np.array([4, 4, 4])
T = np.dot(np.stack([x, y, z]), S - O)

# 6.坐标变化：目标空间->原空间
N = np.dot(np.stack([x, y, z], axis=1), T) + O
print(np.allclose(S, N))

# 7.由正交基组成的矩阵，其逆矩阵和转置矩阵相同
b = np.stack([x, y, z], axis=1)
print(np.allclose(b.T, np.linalg.inv(b)))

import weakref


class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point[{self.x}, {self.y}]"


if __name__ == '__main__':
    a = Point(3, 4)
    b = weakref.ref(a)
    print(b, b())
    del a
    print(b, b())

import numpy as np
import matplotlib.pyplot as plt


def signal(t):
    """
    连续信号，频谱中有两个正弦波，周期分别为pi和pi/2，最大频率为2/pi
    :param t: 时间
    :return: 信号值
    """
    return np.sin(t) + np.sin(2 * t)


def restored(t, f, N, M):
    """
    使用香农插值公式，将离散信号还原成连续信号
    :param t: 时间
    :param f: 采样后的离散信号
    :param N: 采样的离散信号点的数量
    :param M: 采样间隔
    :return: 信号
    """
    y = 0
    for n in range(N):
        y += f[n] * np.sinc(t / M - n)
    return y


def main():
    M = np.pi / 4  # 采样间隔，采样频率要大于2倍的2/pi，采样间隔要小于pi/4
    N = 20  # 样本数量
    f = [signal(n * M) for n in range(N)]  # 离散信号点

    x = np.linspace(0, (N - 1) * M, 100)

    ax = plt.subplot(121)
    ax.set_xlabel("t")
    plt.plot(x, signal(x), label="original signal")
    plt.scatter(np.arange(0, N * M, M), f, color="red", label="samples", zorder=3)
    plt.legend()

    ax = plt.subplot(122)
    ax.set_xlabel("t")
    plt.plot(x, restored(x, f, N, M), label="restored signal")
    plt.scatter(np.arange(0, N * M, M), f, color="red", label="samples", zorder=3)
    plt.legend()

    plt.show()


if __name__ == '__main__':
    main()

import numpy as np
import utils


def sigmoid_ext(x, beta=20):
    return 1 / (1 + np.exp(-beta * x))


utils.plot(sigmoid_ext, start=-1, end=1, pn=50, save_file="f.png")