l0n0lc 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

l0n0lc/StdList.py

@@ -0,0 +1,24 @@
+from .c基础处理 import c变量, cpp类型, list初始化列表
+
+
+class StdList(c变量):
+    def __init__(
+            self,
+            初始化列表: list初始化列表,
+            名字: str, 是参数: bool) -> None:
+        self.初始化列表 = 初始化列表
+        if 初始化列表.类型 == cpp类型.ANY:
+            super().__init__(f'std::vector<{初始化列表.类型}>', 名字, 是参数)
+        else:
+            super().__init__(f'{初始化列表.类型}', 名字, 是参数)
+
+    def __getitem__(self, key):
+        return f'{self}[{key}]'
+
+    def __setitem__(self, key, value):
+        return f'{self}[{key}] = {value};'
+
+    def 初始化(self, 初始值):
+        if self.初始化列表.类型 == cpp类型.ANY:
+            return super().初始化(初始值)
+        return f'{self.类型} {self.名字}[] = {初始值};'

l0n0lc/StdMap.py

@@ -0,0 +1,21 @@
+from .c基础处理 import py类型转c类型, dict初始化列表, c变量, cpp类型
+from typing import Tuple, Union, List
+from .通用 import toCString
+
+
+class StdUnorderedMap(c变量):
+    def __init__(
+            self,
+            初始化列表: dict初始化列表,
+            名字: str, 是参数: bool) -> None:
+        self.初始化列表 = 初始化列表
+        super().__init__(
+            f'std::unordered_map<{初始化列表.key类型}, {初始化列表.value类型}>', 名字, 是参数)
+
+    def __getitem__(self, key):
+        return f'{self}[{toCString(key)}]'
+
+    def __setitem__(self, key, value):
+        左 = f'{self}[{toCString(key)}]'
+        右 = toCString(value)
+        return f'{左} = {右};'

l0n0lc/__init__.py

@@ -1,6 +1,6 @@
-from .输出 import 配置输出函数
-from .c类型基础 import c类型基础, c_void, c_void_p, c函数, c结构体, c数组
-from .c域 import 花括号, 如果, 否则, 否则如果, 循环, 输出
-from .c基础类型 import *
-from .c语句 import *
-from .编译 import 编译
+from .通用 import *
+from .c基础处理 import *
+from .StdList import *
+from .编译 import *
+from .StdMap import *
+from .jit import *

l0n0lc/c/345/237/272/347/241/200/345/244/204/347/220/206.py

@@ -0,0 +1,307 @@
+from typing import Union, List, get_origin, get_args
+from .通用 import 生成变量Id, toCString
+import numpy as np
+import ctypes
+
+
+def cpp获取变量类型(v):
+    return f'decltype({v})'
+
+
+class cpp类型:
+    INT8_T = 'int8_t'
+    INT16_T = 'int16_t'
+    INT32_T = 'int32_t'
+    INT64_T = 'int64_t'
+    UINT8_T = 'uint8_t'
+    UINT16_T = 'uint16_t'
+    UINT32_T = 'uint32_t'
+    UINT64_T = 'uint64_t'
+    HALF = 'half'
+    FLOAT = 'float'
+    STRING = 'std::string'
+    BOOL = 'bool'
+    ANY = 'std::any'
+    AUTO = 'auto'
+    VOID_P = 'void*'
+
+
+class 指针:
+    def __init__(self, 类型) -> None:
+        self.基础类型 = 类型
+
+    def __str__(self) -> str:
+        return f'{self.基础类型}*'
+
+
+def 执行额外函数(函数列表: List, *args):
+    for fn in 函数列表:
+        ret = fn(*args)
+        if ret is not None:
+            return ret
+
+
+额外py转ctypes函数 = []
+
+
+def py类型转ctypes类型(类型):
+    ret = 执行额外函数(额外py转ctypes函数, 类型)
+    if ret is not None:
+        return ret
+
+    # 基础类型
+    if 类型 is int:
+        return ctypes.c_int64
+    if 类型 is float:
+        return ctypes.c_float
+    if 类型 is str:
+        return ctypes.c_char_p
+    if 类型 is bool:
+        return ctypes.c_bool
+    if 类型 is 指针:
+        return ctypes.c_void_p
+
+    # numpy dtype 转换
+    return numpy类型转ctypes类型(类型)
+
+
+额外py转c函数 = []
+
+
+def py类型转c类型(类型):
+    ret = 执行额外函数(额外py转c函数, 类型)
+    if ret is not None:
+        return ret
+
+    # 基础类型
+    if 类型 is int:
+        return cpp类型.INT64_T
+    if 类型 is float:
+        return cpp类型.FLOAT
+    if 类型 is str:
+        return cpp类型.STRING
+    if 类型 is bool:
+        return cpp类型.BOOL
+    if 类型 is 指针:
+        return cpp类型.VOID_P
+
+    origin = get_origin(类型)
+    args = get_args(类型)
+
+    if origin is Union:
+        return cpp类型.ANY
+
+    # List[...] → 指针(...)
+    if origin is list:
+        if args:
+            elem_type = args[0]
+            return 指针(py类型转c类型(elem_type))
+
+    # Dict[K, V] → std::unordered_map<K, V>
+    if origin is dict:
+        if len(args) == 2:
+            key_type = py类型转c类型(args[0])
+            val_type = py类型转c类型(args[1])
+            return f"std::unordered_map<{key_type}, {val_type}>&"
+
+    # numpy dtype 转换
+    ret = numpy类型转c类型(类型)
+    if ret is not None:
+        return ret
+
+    # 直接传字符串类型名
+    if isinstance(类型, str):
+        return 类型
+
+    return cpp类型.ANY
+
+
+额外numpy转ctypes函数 = []
+
+
+def numpy类型转ctypes类型(npdtype):
+    ret = 执行额外函数(额外numpy转ctypes函数, npdtype)
+    if ret is not None:
+        return ret
+
+    if npdtype == np.int8:
+        return ctypes.c_int8
+    if npdtype == np.int16:
+        return ctypes.c_int16
+    if npdtype == np.int32:
+        return ctypes.c_int32
+    if npdtype == np.int64:
+        return ctypes.c_int64
+    if npdtype == np.uint8:
+        return ctypes.c_uint8
+    if npdtype == np.uint16:
+        return ctypes.c_uint16
+    if npdtype == np.uint32:
+        return ctypes.c_uint32
+    if npdtype == np.uint64:
+        return ctypes.c_uint64
+    try:
+        if npdtype == np.bool_:
+            return ctypes.c_bool
+    except:
+        pass
+    try:
+        if npdtype == np.bool:  # type: ignore
+            return ctypes.c_bool
+    except:
+        pass
+    if npdtype == np.float32:
+        return ctypes.c_float
+    if npdtype == np.float64:
+        return ctypes.c_double
+
+
+额外numpy转c函数 = []
+
+
+def numpy类型转c类型(npdtype):
+    ret = 执行额外函数(额外numpy转c函数, npdtype)
+    if ret is not None:
+        return ret
+
+    if npdtype == np.int8:
+        return cpp类型.INT8_T
+    if npdtype == np.int16:
+        return cpp类型.INT16_T
+    if npdtype == np.int32:
+        return cpp类型.INT32_T
+    if npdtype == np.int64:
+        return cpp类型.INT64_T
+    if npdtype == np.uint8:
+        return cpp类型.UINT8_T
+    if npdtype == np.uint16:
+        return cpp类型.UINT16_T
+    if npdtype == np.uint32:
+        return cpp类型.UINT32_T
+    if npdtype == np.uint64:
+        return cpp类型.UINT64_T
+    try:
+        if npdtype == np.bool_:
+            return cpp类型.BOOL
+    except:
+        pass
+    try:
+        if npdtype == np.bool:  # type: ignore
+            return cpp类型.BOOL
+    except:
+        pass
+    if npdtype == np.float16:
+        return cpp类型.HALF
+    if npdtype == np.float32:
+        return cpp类型.FLOAT
+
+
+def cpp类型检查(类型, 支持提示: str):
+    if 类型 not in [int, float, str, bool]:
+        raise Exception(f'{支持提示} 仅支持 [int, float, str, bool]')
+
+
+class list初始化列表:
+    def __init__(
+            self,
+            代码: str,
+            类型列表: Union[List[Union[int, float, bool, str]],
+                        int, float, bool, str],
+            长度: int) -> None:
+        self.代码 = 代码
+        self.类型列表 = 类型列表
+        self.类型 = py类型转c类型(类型列表)
+        self.长度 = 长度
+
+    def __str__(self) -> str:
+        return self.代码
+
+
+def 从list构建初始化列表(value: List):
+    数据类型列表 = []
+    初始化列表 = []
+    for v in value:
+        dtype = type(v)
+        cpp类型检查(dtype, 'List')
+        数据类型列表.append(dtype)
+        初始化列表.append(toCString(v))
+    # 构建初始化列表
+    初始化列表 = '{' + ','.join(初始化列表) + '}'
+
+    # 构建类型列表
+    if all(类型 == 数据类型列表[0] for 类型 in 数据类型列表):
+        数据类型列表 = 数据类型列表[0]
+
+    return list初始化列表(初始化列表, 数据类型列表, len(value))
+
+
+def 从ndarray构建初始化列表(value: np.ndarray):
+    value = value.reshape(value.size)
+    类型 = numpy类型转c类型(value.dtype)
+    if 类型 is None:
+        raise Exception(f'暂不支持{value.dtype}')
+    初始化列表 = '{' + ','.join(value) + '}'
+    return list初始化列表(初始化列表, 类型, value.size)
+
+
+class dict初始化列表:
+    def __init__(
+            self,
+            代码: str,
+            key类型列表: Union[List[Union[int, float, bool, str]],
+                           int, float, bool, str],
+            value类型列表: Union[List[Union[int, float, bool, str]],
+                             int, float, bool, str]) -> None:
+        self.代码 = 代码
+        self.key类型列表 = key类型列表
+        self.value类型列表 = value类型列表
+        self.key类型 = py类型转c类型(key类型列表)
+        self.value类型 = py类型转c类型(value类型列表)
+
+    def __str__(self) -> str:
+        return self.代码
+
+
+def 从dict构建初始化列表(value: dict):
+    code = []
+    key类型列表 = []
+    value类型列表 = []
+    for k, v in value.items():
+        key类型 = type(k)
+        cpp类型检查(key类型, 'Map')
+        value类型 = type(v)
+        cpp类型检查(value类型, 'Map')
+        key类型列表.append(key类型)
+        value类型列表.append(value类型)
+        code.append(f'{{ {toCString(k)}, {v} }}')
+
+    # 构建类型列表
+    if all(类型 == key类型列表[0] for 类型 in key类型列表):
+        key类型列表 = key类型列表[0]
+
+    if all(类型 == value类型列表[0] for 类型 in value类型列表):
+        value类型列表 = value类型列表[0]
+
+    # 构建初始化列表
+    初始化列表 = '{' + ','.join(code) + '}'
+
+    return dict初始化列表(初始化列表, key类型列表, value类型列表)
+
+
+class c变量:
+    def __init__(self, 类型: str, 名字: str, 是参数: bool, 默认值=None) -> None:
+        self.类型 = 类型
+        self.名字 = 名字
+        self.c名字 = 生成变量Id(名字)
+        self.是参数 = 是参数
+        self.默认值 = 默认值
+
+    def __str__(self):
+        return self.c名字
+
+    @property
+    def c类型(self):
+        return cpp获取变量类型(self)
+
+    def 初始化(self, 初始值):
+        return f'{self.类型} {self.c名字} = {初始值};'