Magma、Python、MATLAB代码展示
学术研究常用Magma、Python、MATLAB代码，点击复制按钮即可使用
// --------------------------
// 可修改的参数（只需改这里）
// --------------------------
p := 37; // 有限域大小
poly_expr := x^18 -36; // 多项式表达式（x已预先定义）
// --------------------------
// 核心逻辑（无需修改）
// --------------------------
F := GF(p); // 定义有限域
P := PolynomialRing(F); // 定义多项式环
x := P.1; // 定义变量x
f := poly_expr; // 构造多项式
// 输出多项式
printf "Polynomial: %o\n", f;
// 因式分解
factors := Factorization(f);
// 输出因子
printf "Factors:\n";
i := 1;
while i le #factors do
factor := factors[i][1];
mult := factors[i][2];
printf " Factor %o: %o with multiplicity %o\n", i, factor, mult;
i := i + 1;
end while;
// 提取根
printf "Roots in GF(%o): ", p;
roots := [];
i := 1;
while i le #factors do
fac := factors[i][1];
if Degree(fac) eq 1 then
Append(~roots, -Coefficient(fac, 0));
end if;
i := i + 1;
end while;
printf "%o\n", roots;
F := GF(23);
G := Matrix(F, 2, 11, [ 6, 7, 4, 11, 3, 9, 5, 8, 10, 1, 2,
12, 19, 2, 13, 11, 4, 13, 6, 3, 19, 17]);
C := LinearCode(G);
d := MinimumDistance(C);
H := ParityCheckMatrix(C);
W := WeightDistribution(C);
C1 := LinearCode(H);
d1 := MinimumDistance(C1);
C;
W;
C1;
d;
d1;
// 判断MDS（修正后的逻辑）
if IsMDS(C) then
"MDS code true";
else
"MDS code false";
end if;
// 判断LCD
if IsSingular(G * Transpose(G)) then
"LCD code false";
else
"LCD code true";
end if;
// 判断Selforthogonal
if IsZero(G * Transpose(G)) then
"Selforthogonal code true";
else
"Selforthogonal code false";
end if;
// 判断自对偶
if IsSelfDual(C) then
"SelfDual code true";
else
"SelfDual code false";
end if;
// 判断射影码
if IsProjective(C) then
"Projective code true";
else
"Projective code false";
end if;
import tkinter as tk
from tkinter import messagebox
def compute_n_given_phi():
try:
k = int(entry_k.get())
if k <= 0:
messagebox.showerror(
"Invalid Input", "Please enter a positive integer for k.")
return
# Function to find all n such that φ(n) = k
n_values = find_n_given_phi(k)
if not n_values:
result = f"No integers n satisfy φ(n) = {k}."
else:
result = f"Integers n such that φ(n) = {k}:\n{n_values}"
text_result.config(state='normal')
text_result.delete('1.0', tk.END)
text_result.insert(tk.END, result)
text_result.config(state='disabled')
except ValueError:
messagebox.showerror(
"Invalid Input", "Please enter a valid integer for k.")
def find_n_given_phi(k):
# We'll search for n in a reasonable range
# Since φ(n) ≤ n - 1, n can at most be k + 1
# But in general, n can be larger, so let's set an upper limit
# For practical purposes, we can search up to n = 10k
max_n = 10 * k
n_values = []
for n in range(1, max_n + 1):
if euler_phi(n) == k:
n_values.append(n)
return n_values
def euler_phi(n):
# Euler's Totient Function implementation
result = n
p = 2
while p * p <= n:
if n % p == 0:
while n % p == 0:
n = n // p
result -= result // p
p += 1
if n > 1:
result -= result // n
return result
# Create the main window
root = tk.Tk()
root.title("Find n given φ(n) = k")
# Create and place the widgets
label_k = tk.Label(root, text="Enter a positive integer (k):")
label_k.pack(pady=5)
entry_k = tk.Entry(root)
entry_k.pack(pady=5)
button_compute = tk.Button(
root, text="Find n such that φ(n) = k", command=compute_n_given_phi)
button_compute.pack(pady=10)
text_result = tk.Text(root, height=15, width=50, state='disabled')
text_result.pack(pady=5)
# Start the main event loop
root.mainloop()
from math import sqrt, floor
from typing import Dict
def prime_factors(n: int) -> Dict[int, int]:
"""计算一个数的素因数分解"""
factors = {}
num = n
# 处理2的因子
while num % 2 == 0:
factors[2] = factors.get(2, 0) + 1
num //= 2
# 处理奇数因子
i = 3
while i * i <= num:
while num % i == 0:
factors[i] = factors.get(i, 0) + 1
num //= i
i += 2
# 如果num大于2，说明剩下的就是一个素数
if num > 2:
factors[num] = 1
return factors
def SL(m: int) -> int:
"""计算SL(m)=min{n∈Z⁺:m|gcd(1,2,…,n)}"""
if m == 1:
return 1
# 获取m的素因数分解
factors = prime_factors(m)
max_required = 0
# 对每个素因子p^k，我们需要p^k
for p, k in factors.items():
current = pow(p, k) # 使用内置的pow函数
max_required = max(max_required, current)
return max_required
def S(m: int) -> int:
"""计算S(m)=min{n∈Z⁺:m|n!}"""
if m == 1:
return 1
# 获取m的素因数分解
factors = prime_factors(m)
max_required = 0
# 对于每个素因子p^k，计算需要多少个数字来达到足够的p的幂次
for p, k in factors.items():
total_power = 0
n = 0
while total_power < k:
n += 1
temp = n
contribution = 0
while temp >= p:
contribution += temp // p
temp //= p
total_power = contribution
max_required = max(max_required, n)
return max_required
def calculate_S_SL(base: int, power: int) -> int:
"""计算S(SL(base^power))的值"""
try:
# 先计算base^power的素因数分解
base_factors = prime_factors(base)
power_factors = {}
# 计算幂后的素因数分解
for p, k in base_factors.items():
power_factors[p] = k * power
# 计算SL值
sl_result = 1
for p, k in power_factors.items():
current = pow(p, k)
sl_result = max(sl_result, current)
# 计算S值
return S(sl_result)
except Exception as e:
print(f"计算过程中出现错误: {e}")
return None
def main():
"""主函数，处理用户输入并计算结果"""
while True:
try:
# 获取用户输入
print("\n请输入两个数字（输入非数字退出）：")
base = input("请输入底数n: ")
if not base.isdigit():
print("程序退出")
break
power = input("请输入幂次m: ")
if not power.isdigit():
print("程序退出")
break
# 转换为整数
base = int(base)
power = int(power)
# 检查输入是否合理
if base <= 0 or power <= 0:
print("请输入正整数！")
continue
# 计算结果
print(f"\n计算 S(SL({base}^{power})) 的值...")
result = calculate_S_SL(base, power)
if result is not None:
print(f"S(SL({base}^{power})) = {result}")
except ValueError:
print("请输入有效的正整数！")
except Exception as e:
print(f"发生错误: {e}")
if __name__ == "__main__":
main()