l0n0lc 0.8.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

l0n0lc/simd/344/274/230/345/214/226.py

@@ -0,0 +1,260 @@
+"""
+SIMD (Single Instruction Multiple Data) 向量化优化模块
+
+提供 SIMD 指令的自动检测和向量化优化支持
+"""
+
+import os
+import subprocess
+import platform
+from typing import Optional, List, Dict, Any
+from .日志工具 import 日志
+
+
+class CPU特性:
+    """CPU SIMD 特性检测"""
+
+    def __init__(self):
+        self._特性缓存: Optional[Dict[str, bool]] = None
+
+    def 检测特性(self) -> Dict[str, bool]:
+        """
+        检测 CPU 支持的 SIMD 特性
+
+        Returns:
+            特性字典，包含各种 SIMD 扩展的支持情况
+        """
+        if self._特性缓存 is not None:
+            return self._特性缓存
+
+        特性 = {
+            'SSE': False,
+            'SSE2': False,
+            'SSE3': False,
+            'SSE4_1': False,
+            'SSE4_2': False,
+            'AVX': False,
+            'AVX2': False,
+            'AVX512F': False,
+            'NEON': False,  # ARM
+        }
+
+        系统 = platform.system()
+
+        if 系统 == 'Linux':
+            # Linux: 读取 /proc/cpuinfo
+            try:
+                with open('/proc/cpuinfo', 'r') as f:
+                    内容 = f.read()
+                    特性.update(self._从cpuinfo解析(内容))
+            except (FileNotFoundError, PermissionError, OSError) as e:
+                日志.调试(f"无法读取 /proc/cpuinfo: {e}")
+            except Exception as e:
+                日志.调试(f"解析 cpuinfo 时出错: {e}")
+
+            # 尝试通过 lscpu 获取更准确的信息
+            try:
+                结果 = subprocess.run(['lscpu'], capture_output=True, text=True, timeout=5)
+                if 结果.returncode == 0:
+                    特性.update(self._从lscpu解析(结果.stdout))
+            except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError) as e:
+                日志.调试(f"无法执行 lscpu: {e}")
+            except Exception as e:
+                日志.调试(f"解析 lscpu 输出时出错: {e}")
+
+        elif 系统 == 'Darwin':  # macOS
+            # macOS: 使用 sysctl
+            try:
+                结果 = subprocess.run(['sysctl', '-a'], capture_output=True, text=True, timeout=5)
+                if 结果.returncode == 0:
+                    特性.update(self._从sysctl解析(结果.stdout))
+            except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError) as e:
+                日志.调试(f"无法执行 sysctl: {e}")
+            except Exception as e:
+                日志.调试(f"解析 sysctl 输出时出错: {e}")
+
+        elif 系统 == 'Windows':
+            # Windows: 使用 wmic 或 systeminfo
+            try:
+                结果 = subprocess.run(
+                    ['wmic', 'cpu', 'get', 'DataWidth', '/format:list'],
+                    capture_output=True, text=True, timeout=5
+                )
+                if 结果.returncode == 0:
+                    # Windows 上的简化检测，假设支持 SSE2+
+                    特性['SSE2'] = True
+            except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError) as e:
+                日志.调试(f"无法执行 wmic: {e}")
+            except Exception as e:
+                日志.调试(f"解析 wmic 输出时出错: {e}")
+
+        # ARM 架构特殊处理
+        机器 = platform.machine()
+        if 机器 and ('arm' in 机器.lower() or 'aarch64' in 机器.lower()):
+            特性['NEON'] = True
+
+        self._特性缓存 = 特性
+        return 特性
+
+    def _从cpuinfo解析(self, 内容: str) -> Dict[str, bool]:
+        """从 /proc/cpuinfo 解析 CPU 特性"""
+        特性 = {}
+
+        for 行 in 内容.split('\n'):
+            if 行.startswith('flags'):
+                标志列表 = 行.split(':', 1)[1].strip().split()
+                标志 = set(标志列表)
+
+                特性['SSE'] = 'sse' in 标志
+                特性['SSE2'] = 'sse2' in 标志
+                特性['SSE3'] = 'sse3' in 标志 or 'pni' in 标志
+                特性['SSE4_1'] = 'sse4_1' in 标志
+                特性['SSE4_2'] = 'sse4_2' in 标志
+                特性['AVX'] = 'avx' in 标志
+                特性['AVX2'] = 'avx2' in 标志
+                特性['AVX512F'] = 'avx512f' in 标志
+                break
+
+        return 特性
+
+    def _从lscpu解析(self, 内容: str) -> Dict[str, bool]:
+        """从 lscpu 输出解析 CPU 特性"""
+        特性 = {}
+
+        for 行 in 内容.split('\n'):
+            if 'Flags:' in 行:
+                标志列表 = 行.split(':', 1)[1].strip().split()
+                标志 = set(标志列表)
+
+                特性['SSE'] = 'sse' in 标志
+                特性['SSE2'] = 'sse2' in 标志
+                特性['SSE3'] = 'sse3' in 标志 or 'pni' in 标志
+                特性['SSE4_1'] = 'sse4_1' in 标志
+                特性['SSE4_2'] = 'sse4_2' in 标志
+                特性['AVX'] = 'avx' in 标志
+                特性['AVX2'] = 'avx2' in 标志
+                特性['AVX512F'] = 'avx512f' in 标志
+                break
+
+        return 特性
+
+    def _从sysctl解析(self, 内容: str) -> Dict[str, bool]:
+        """从 sysctl 输出解析 CPU 特性（macOS）"""
+        特性 = {}
+
+        # macOS 通常在较新的 Intel 处理器上支持 AVX
+        if 'machdep.cpu.features' in 内容:
+            for 行 in 内容.split('\n'):
+                if 'machdep.cpu.features:' in 行 or 'machdep.cpu.extfeatures:' in 行:
+                    标志列表 = 行.split(':', 1)[1].strip().split()
+                    标志 = set(标志列表)
+
+                    特性['SSE'] = 'SSE' in 标志
+                    特性['SSE2'] = 'SSE2' in 标志
+                    特性['SSE3'] = 'SSE3' in 标志
+                    特性['SSE4_1'] = 'SSE4.1' in 标志 or 'SSE4_1' in 标志
+                    特性['SSE4_2'] = 'SSE4.2' in 标志 or 'SSE4_2' in 标志
+                    特性['AVX'] = 'AVX' in 标志
+                    特性['AVX2'] = 'AVX2' in 标志
+                    特性['AVX512F'] = 'AVX512F' in 标志 or 'AVX512' in 标志
+                    break
+
+        return 特性
+
+    def 获取最佳SIMD指令集(self) -> str:
+        """
+        获取 CPU 支持的最佳 SIMD 指令集
+
+        Returns:
+            最佳指令集名称 (SSE2, SSE4_2, AVX2, AVX512F, NEON)
+        """
+        特性 = self.检测特性()
+
+        优先级 = ['AVX512F', 'AVX2', 'SSE4_2', 'SSE2', 'NEON']
+
+        for 指令集 in 优先级:
+            if 特性.get(指令集, False):
+                return 指令集
+
+        return 'SSE2'  # 默认回退
+
+
+# 全局单例
+_CPU特性实例: Optional[CPU特性] = None
+
+
+def 获取CPU特性() -> CPU特性:
+    """获取 CPU 特性检测器单例"""
+    global _CPU特性实例
+    if _CPU特性实例 is None:
+        _CPU特性实例 = CPU特性()
+    return _CPU特性实例
+
+
+def 获取最佳SIMD指令集() -> str:
+    """获取当前 CPU 支持的最佳 SIMD 指令集"""
+    return 获取CPU特性().获取最佳SIMD指令集()
+
+
+def 获取SIMD编译标志(指令集: Optional[str] = None) -> List[str]:
+    """
+    获取 SIMD 编译标志
+
+    Args:
+        指令集: 指定指令集，None 表示自动检测
+
+    Returns:
+        编译标志列表
+    """
+    if 指令集 is None:
+        指令集 = 获取最佳SIMD指令集()
+
+    标志映射 = {
+        'SSE2': ['-msse2', '-mfpmath=sse'],
+        'SSE4_2': ['-msse4.2', '-mfpmath=sse'],
+        'AVX': ['-mavx'],
+        'AVX2': ['-mavx2', '-mfma'],
+        'AVX512F': ['-mavx512f', '-mavx512vl'],
+        'NEON': [],  # ARM NEON 通常默认启用
+    }
+
+    return 标志映射.get(指令集, ['-msse2'])
+
+
+def 启用自动向量化标志() -> List[str]:
+    """
+    获取启用编译器自动向量化的标志
+
+    Returns:
+        编译标志列表
+    """
+    return ['-ftree-vectorize', '-ffast-math']
+
+
+def 获取向量化宏定义(指令集: Optional[str] = None) -> Dict[str, str]:
+    """
+    获取 SIMD 向量化相关的宏定义
+
+    Args:
+        指令集: 指定指令集，None 表示自动检测
+
+    Returns:
+        宏定义字典
+    """
+    if 指令集 is None:
+        指令集 = 获取最佳SIMD指令集()
+
+    宏定义 = {
+        'L0N0LC_USE_SIMD': '1',
+    }
+
+    if 指令集 == 'AVX2':
+        宏定义['L0N0LC_AVX2'] = '1'
+    elif 指令集 == 'AVX512F':
+        宏定义['L0N0LC_AVX512F'] = '1'
+    elif 指令集 == 'NEON':
+        宏定义['L0N0LC_NEON'] = '1'
+    else:
+        宏定义['L0N0LC_SSE'] = '1'
+
+    return 宏定义

l0n0lc/std_map.py

@@ -0,0 +1,153 @@
+
+from .cpp类型 import 字典初始化列表, C变量
+from .工具 import 转C字符串
+from .转译器工具 import 获取当前transpiler
+
+
+class 标准无序映射(C变量):
+    def __init__(
+            self,
+            初始化列表: 字典初始化列表,
+            名称: str,
+            是否参数: bool) -> None:
+        self.初始化列表 = 初始化列表
+        super().__init__(
+            f'std::unordered_map<{初始化列表.键类型名}, {初始化列表.值类型名}>', 名称, 是否参数)
+
+    def __getitem__(self, key):
+        return f'{self}[{转C字符串(key)}]'
+
+    def __setitem__(self, key, value):
+        left = f'{self}[{转C字符串(key)}]'
+        right = 转C字符串(value)
+        return f'{left} = {right};'
+
+    def _获取transpiler(self):
+        """获取当前transpiler实例来添加必要的头文件"""
+        return 获取当前transpiler()
+
+    # Python dict 方法映射到 C++ std::unordered_map
+    def get(self, key, default=None):
+        """安全获取值，如果键不存在则返回默认值"""
+        if default is None:
+            return f"({self}.find({转C字符串(key)}) != {self}.end() ? {self}.at({转C字符串(key)}) : decltype({self}.at({转C字符串(key)})){{}})"
+        else:
+            return f"({self}.find({转C字符串(key)}) != {self}.end() ? {self}.at({转C字符串(key)}) : {转C字符串(default)})"
+
+    def pop(self, key, default=None):
+        """移除并返回指定键的值"""
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<utility>")  # for std::move
+            transpiler.包含头文件.add("<stdexcept>")  # for std::out_of_range
+
+        if default is None:
+            return f"""
+            [&]{{
+                auto it = {self}.find({转C字符串(key)});
+                if (it != {self}.end()) {{
+                    auto value = std::move(it->second);
+                    {self}.erase(it);
+                    return value;
+                }}
+                throw std::out_of_range("Key not found");
+            }}()
+            """.strip()
+        else:
+            return f"""
+            [&]{{
+                auto it = {self}.find({转C字符串(key)});
+                if (it != {self}.end()) {{
+                    auto value = std::move(it->second);
+                    {self}.erase(it);
+                    return value;
+                }}
+                return {转C字符串(default)};
+            }}()
+            """.strip()
+
+    def popitem(self):
+        """移除并返回一个键值对（C++中返回第一个元素）"""
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<utility>")  # for std::pair
+            transpiler.包含头文件.add("<stdexcept>")  # for std::out_of_range
+
+        return f"""
+        [&]{{
+            if (!{self}.empty()) {{
+                auto it = {self}.begin();
+                auto item = std::make_pair(it->first, std::move(it->second));
+                {self}.erase(it);
+                return item;
+            }}
+            throw std::out_of_range("Dictionary is empty");
+        }}()
+        """.strip()
+
+    def setdefault(self, key, default):
+        """设置默认值，如果键不存在则设置并返回默认值"""
+        return f"""
+        [&]{{
+            auto result = {self}.emplace({转C字符串(key)}, {转C字符串(default)});
+            if (result.second) {{
+                return result.first->second;
+            }}
+            return {self}.at({转C字符串(key)});
+        }}()
+        """.strip()
+
+    def update(self, other_dict):
+        """用另一个字典更新当前字典"""
+        return f"""
+        [&]{{
+            for(const auto& pair : {other_dict}) {{
+                {self}[pair.first] = pair.second;
+            }}
+            return {self}.size();
+        }}()
+        """.strip()
+
+    def clear(self):
+        """清空字典"""
+        return f"{self}.clear();"
+
+    def size(self):
+        """返回字典大小（len() 函数会使用这个）"""
+        return f"{self}.size()"
+
+    def empty(self):
+        """检查字典是否为空"""
+        return f"{self}.empty()"
+
+    def contains(self, key):
+        """检查键是否存在（用于 'in' 操作符）"""
+        return f"{self}.find({转C字符串(key)}) != {self}.end()"
+
+    def keys(self):
+        """返回所有键的视图（用于遍历）"""
+        return self
+
+    def values(self):
+        """返回所有值的视图（用于遍历）"""
+        return self
+
+    def items(self):
+        """返回所有键值对的视图（用于遍历）"""
+        return self
+
+    def begin(self):
+        """返回指向开始位置的迭代器（用于内部操作）"""
+        return f"{self}.begin()"
+
+    def end(self):
+        """返回指向结束位置的迭代器（用于内部操作）"""
+        return f"{self}.end()"
+
+    def find(self, key):
+        """查找指定键的迭代器"""
+        return f"{self}.find({转C字符串(key)})"
+
+    def erase(self, iterator_or_key):
+        """删除指定位置的元素（内部使用）"""
+        return f"{self}.erase({iterator_or_key})"

l0n0lc/std_set.py

@@ -0,0 +1,185 @@
+from .cpp类型 import 集合初始化列表, C变量
+from .转译器工具 import 获取当前transpiler
+
+
+class 标准集合(C变量):
+    def __init__(self, 初始化列表: 集合初始化列表, 名称: str, 是否参数: bool) -> None:
+        self.初始化列表 = 初始化列表
+        super().__init__(f"std::unordered_set<{初始化列表.类型名}>", 名称, 是否参数)
+
+    def add(self, value):
+        return f"{self}.insert({str(value)});"
+
+    def remove(self, value):
+        return f"{self}.erase({str(value)});"
+
+    def update(self, other_set):
+        """将另一个集合的所有元素添加到当前集合（就地修改）"""
+        return f"""
+        [&]{{
+            for(const auto& elem : {other_set}) {{
+                {self}.insert(elem);
+            }}
+            return {self};
+        }}()
+        """.strip()
+
+    def __contains__(self, item):
+        # This will be used in 'item in set'
+        # But transpiler handles 'in' via Compare?
+        # If transpiler calls this, fine.
+        return f"{self}.find({str(item)}) != {self}.end()"
+
+    def _获取transpiler(self):
+        """获取当前transpiler实例来添加必要的头文件"""
+        return 获取当前transpiler()
+
+    # Python set 方法映射到 C++ std::unordered_set
+    def clear(self):
+        """清空集合"""
+        return f"{self}.clear();"
+
+    def size(self):
+        """返回集合大小（len() 函数会使用这个）"""
+        return f"{self}.size()"
+
+    def empty(self):
+        """检查集合是否为空"""
+        return f"{self}.empty()"
+
+    def begin(self):
+        """返回指向开始位置的迭代器（用于内部操作）"""
+        return f"{self}.begin()"
+
+    def end(self):
+        """返回指向结束位置的迭代器（用于内部操作）"""
+        return f"{self}.end()"
+
+    def find(self, value):
+        """查找指定值的迭代器"""
+        return f"{self}.find({str(value)})"
+
+    def erase(self, value_or_iterator):
+        """删除指定值或迭代器位置的元素"""
+        return f"{self}.erase({value_or_iterator})"
+
+    def union(self, other_set):
+        """返回两个集合的并集"""
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<unordered_set>")
+
+        return f"""
+        [&]{{
+            auto result = {self};
+            for(const auto& elem : {other_set}) {{
+                result.insert(elem);
+            }}
+            return result;
+        }}()
+        """.strip()
+
+    def intersection(self, other_set):
+        """返回两个集合的交集"""
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<unordered_set>")
+
+        return f"""
+        [&]{{
+            decltype({self}) result;
+            for(const auto& elem : {self}) {{
+                if ({other_set}.find(elem) != {other_set}.end()) {{
+                    result.insert(elem);
+                }}
+            }}
+            return result;
+        }}()
+        """.strip()
+
+    def difference(self, other_set):
+        """返回两个集合的差集"""
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<unordered_set>")
+
+        return f"""
+        [&]{{
+            decltype({self}) result;
+            for(const auto& elem : {self}) {{
+                if ({other_set}.find(elem) == {other_set}.end()) {{
+                    result.insert(elem);
+                }}
+            }}
+            return result;
+        }}()
+        """.strip()
+
+    def issubset(self, other_set):
+        """检查当前集合是否为另一个集合的子集"""
+        return f"""
+        [&]{{
+            for(const auto& elem : {self}) {{
+                if ({other_set}.find(elem) == {other_set}.end()) {{
+                    return false;
+                }}
+            }}
+            return true;
+        }}()
+        """.strip()
+
+    def issuperset(self, other_set):
+        """检查当前集合是否为另一个集合的超集"""
+        return f"""
+        [&]{{
+            for(const auto& elem : {other_set}) {{
+                if ({self}.find(elem) == {self}.end()) {{
+                    return false;
+                }}
+            }}
+            return true;
+        }}()
+        """.strip()
+
+    def isdisjoint(self, other_set):
+        """检查两个集合是否不相交"""
+        return f"""
+        [&]{{
+            for(const auto& elem : {self}) {{
+                if ({other_set}.find(elem) != {other_set}.end()) {{
+                    return false;
+                }}
+            }}
+            return true;
+        }}()
+        """.strip()
+
+    def discard(self, value):
+        """移除元素，如果元素不存在也不报错"""
+        return f"{self}.erase({str(value)});"
+
+    def pop(self):
+        """移除并返回一个任意元素"""
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<stdexcept>")  # for std::out_of_range
+
+        return f"""
+        [&]{{
+            if (!{self}.empty()) {{
+                auto it = {self}.begin();
+                auto value = *it;
+                {self}.erase(it);
+                return value;
+            }}
+            throw std::out_of_range("Set is empty");
+        }}()
+        """.strip()
+
+    def copy(self):
+        """返回集合的浅拷贝"""
+        return f"{self}"
+
+    def __bool__(self):
+        """支持布尔上下文（用于 if not s 等）"""
+        return f"!{self}.empty()"

l0n0lc/std_vector.py

@@ -0,0 +1,96 @@
+from .cpp类型 import C变量, Cpp类型, 列表初始化列表
+from .转译器工具 import 获取当前transpiler
+
+
+class 标准列表(C变量):
+    def __init__(self, 初始化列表: 列表初始化列表, 名称: str, 是否参数: bool) -> None:
+        self.初始化列表 = 初始化列表
+        if 初始化列表.类型名 == Cpp类型.任意:
+            super().__init__(f"std::vector<{初始化列表.类型名}>", 名称, 是否参数)
+        else:
+            super().__init__(f"std::vector<{初始化列表.类型名}>", 名称, 是否参数)
+
+    def __getitem__(self, key):
+        return f"{self}[{key}]"
+
+    def __setitem__(self, key, value):
+        return f"{self}[{key}] = {value};"
+
+    def 初始化代码(self, initial_value, cast_type: str | None = None):
+        """生成列表变量声明和初始化代码"""
+        # 对于列表，直接使用初始化列表语法，不需要类型转换
+        return f"{self.类型名} {self.C名称} {initial_value};"
+
+    def _获取transpiler(self):
+        """获取当前transpiler实例来添加必要的头文件"""
+        return 获取当前transpiler()
+
+    # Python list 方法映射到 C++ std::vector
+    def append(self, value):
+        """在列表末尾添加元素"""
+        return f"{self}.push_back({value});"
+
+    def extend(self, other_list):
+        """扩展列表，添加另一个列表的所有元素"""
+        return f"""
+        [&]{{
+            for(const auto& elem : {other_list}) {{
+                {self}.push_back(elem);
+            }}
+            return {self}.size();
+        }}()
+        """.strip()
+
+    def insert(self, index, value):
+        """在指定位置插入元素"""
+        return f"{self}.insert({self}.begin() + {index}, {value});"
+
+    def pop(self, index=-1):
+        """移除并返回指定位置的元素"""
+        if index == -1:
+            # 默认移除最后一个元素
+            return f"[&]{{ auto last_elem = {self}.back(); {self}.pop_back(); return last_elem; }}()"
+        else:
+            # 移除指定位置的元素
+            return f"[&]{{ auto elem = {self}[{index}]; {self}.erase({self}.begin() + {index}); return elem; }}()"
+
+    def remove(self, value):
+        """移除第一个匹配的元素"""
+        # 添加algorithm头文件以支持std::find
+        transpiler = self._获取transpiler()
+        if transpiler:
+            transpiler.包含头文件.add("<algorithm>")
+
+        return f"[&]{{ auto it = std::find({self}.begin(), {self}.end(), {value}); if (it != {self}.end()) {{ {self}.erase(it); }} }}()"
+
+    def clear(self):
+        """清空列表"""
+        return f"{self}.clear();"
+
+    def size(self):
+        """返回列表大小（len() 函数会使用这个）"""
+        return f"{self}.size()"
+
+    def empty(self):
+        """检查列表是否为空"""
+        return f"{self}.empty()"
+
+    def front(self):
+        """返回第一个元素"""
+        return f"{self}.front()"
+
+    def back(self):
+        """返回最后一个元素"""
+        return f"{self}.back()"
+
+    def begin(self):
+        """返回指向开始位置的迭代器（用于内部操作）"""
+        return f"{self}.begin()"
+
+    def end(self):
+        """返回指向结束位置的迭代器（用于内部操作）"""
+        return f"{self}.end()"
+
+    def erase(self, iterator):
+        """删除指定位置的元素（内部使用）"""
+        return f"{self}.erase({iterator})"