[2026春季][T1-1-1] HyosungSink

python/infinicore/__init__.py

@@ -76,6 +76,7 @@
 from infinicore.ops.broadcast_to import broadcast_to
 from infinicore.ops.cat import cat
 from infinicore.ops.cdist import cdist
+from infinicore.ops.copysign import copysign
 from infinicore.ops.cross_entropy import cross_entropy
 from infinicore.ops.diff import diff
 from infinicore.ops.digamma import digamma
@@ -95,7 +96,9 @@
 from infinicore.ops.kthvalue import kthvalue
 from infinicore.ops.kv_caching import kv_caching
 from infinicore.ops.ldexp import ldexp
+from infinicore.ops.lcm import lcm
 from infinicore.ops.lerp import lerp
+from infinicore.ops.lgamma import lgamma
 from infinicore.ops.logaddexp import logaddexp
 from infinicore.ops.logaddexp2 import logaddexp2
 from infinicore.ops.logcumsumexp import logcumsumexp
@@ -108,10 +111,12 @@
 from infinicore.ops.mha_varlen import mha_varlen
 from infinicore.ops.mul import mul
 from infinicore.ops.narrow import narrow
+from infinicore.ops.nextafter import nextafter
 from infinicore.ops.nrm2 import nrm2
 from infinicore.ops.paged_attention import paged_attention
 from infinicore.ops.paged_attention_prefill import paged_attention_prefill
 from infinicore.ops.paged_caching import paged_caching
+from infinicore.ops.rad2deg import rad2deg
 from infinicore.ops.rearrange import rearrange
 from infinicore.ops.reciprocal import reciprocal
 from infinicore.ops.rot import rot
@@ -217,6 +222,7 @@
     "bilinear",
     "fmod",
     "cat",
+    "copysign",
     "inner",
     "masked_select",
     "logaddexp",
@@ -231,7 +237,9 @@
     "narrow",
     "nrm2",
     "ldexp",
+    "lcm",
     "lerp",
+    "lgamma",
     "kthvalue",
     "squeeze",
     "unsqueeze",
@@ -246,6 +254,7 @@
     "from_torch",
     "mha_kvcache",
     "mha_varlen",
+    "nextafter",
     "fmin",
     "floor_divide",
     "float_power",
@@ -261,6 +270,7 @@
     "logical_and",
     "vander",
     "paged_caching",
+    "rad2deg",
     "paged_attention",
     "paged_attention_prefill",
     "hypot",

python/infinicore/ops/copysign.py

@@ -0,0 +1,9 @@
+import infinicore
+from infinicore.tensor import Tensor
+
+
+def copysign(input: Tensor, other: Tensor, *, out=None) -> Tensor:
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.copysign(input, other, out=out)
+
+    raise NotImplementedError("copysign is only implemented through the ntops GPU path")

python/infinicore/ops/lcm.py

@@ -0,0 +1,9 @@
+import infinicore
+from infinicore.tensor import Tensor
+
+
+def lcm(input: Tensor, other: Tensor, *, out=None) -> Tensor:
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.lcm(input, other, out=out)
+
+    raise NotImplementedError("lcm is only implemented through the ntops GPU path")

python/infinicore/ops/lgamma.py

@@ -0,0 +1,9 @@
+import infinicore
+from infinicore.tensor import Tensor
+
+
+def lgamma(input: Tensor, *, out=None) -> Tensor:
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.lgamma(input, out=out)
+
+    raise NotImplementedError("lgamma is only implemented through the ntops GPU path")

python/infinicore/ops/nextafter.py

@@ -0,0 +1,9 @@
+import infinicore
+from infinicore.tensor import Tensor
+
+
+def nextafter(input: Tensor, other: Tensor, *, out=None) -> Tensor:
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.nextafter(input, other, out=out)
+
+    raise NotImplementedError("nextafter is only implemented through the ntops GPU path")

python/infinicore/ops/rad2deg.py

@@ -0,0 +1,9 @@
+import infinicore
+from infinicore.tensor import Tensor
+
+
+def rad2deg(input: Tensor, *, out=None) -> Tensor:
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.rad2deg(input, out=out)
+
+    raise NotImplementedError("rad2deg is only implemented through the ntops GPU path")

test/infinicore/ops/copysign.py

@@ -0,0 +1,76 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import infinicore
+import torch
+from framework import BaseOperatorTest, GenericTestRunner, TensorSpec, TestCase
+
+_TEST_CASES_DATA = [
+    ((13, 4), None),
+    ((2, 3, 4), None),
+    ((16, 5632), None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float32: {"atol": 0, "rtol": 0},
+}
+
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            input_spec = TensorSpec.from_tensor(shape, strides, dtype, name="input")
+            other_spec = TensorSpec.from_tensor(shape, strides, dtype, name="other")
+            out_spec = TensorSpec.from_tensor(shape, None, dtype, name="out")
+            tolerance = _TOLERANCE_MAP[dtype]
+
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec, other_spec],
+                    kwargs={},
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tolerance,
+                    description="copysign - OUT_OF_PLACE",
+                )
+            )
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec, other_spec],
+                    kwargs={},
+                    output_spec=out_spec,
+                    comparison_target="out",
+                    tolerance=tolerance,
+                    description="copysign - INPLACE(out)",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    def __init__(self):
+        super().__init__("Copysign")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.copysign(*args, **kwargs)
+
+    def infinicore_operator(self, *args, **kwargs):
+        return infinicore.copysign(*args, **kwargs)
+
+
+def main():
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/lcm.py

@@ -0,0 +1,98 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import infinicore
+import torch
+from framework import (
+    BaseOperatorTest,
+    GenericTestRunner,
+    TensorInitializer,
+    TensorSpec,
+    TestCase,
+)
+
+_TEST_CASES_DATA = [
+    ((13, 4), None),
+    ((2, 3, 4), None),
+    ((16, 5632), None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.int32: {"atol": 0, "rtol": 0},
+}
+
+_TENSOR_DTYPES = [infinicore.int32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            input_spec = TensorSpec.from_tensor(
+                shape,
+                strides,
+                dtype,
+                init_mode=TensorInitializer.RANDINT,
+                low=-100,
+                high=100,
+                name="input",
+            )
+            other_spec = TensorSpec.from_tensor(
+                shape,
+                strides,
+                dtype,
+                init_mode=TensorInitializer.RANDINT,
+                low=-100,
+                high=100,
+                name="other",
+            )
+            out_spec = TensorSpec.from_tensor(shape, None, dtype, name="out")
+            tolerance = _TOLERANCE_MAP[dtype]
+
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec, other_spec],
+                    kwargs={},
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tolerance,
+                    description="lcm - OUT_OF_PLACE",
+                )
+            )
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec, other_spec],
+                    kwargs={},
+                    output_spec=out_spec,
+                    comparison_target="out",
+                    tolerance=tolerance,
+                    description="lcm - INPLACE(out)",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    def __init__(self):
+        super().__init__("Lcm")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.lcm(*args, **kwargs)
+
+    def infinicore_operator(self, *args, **kwargs):
+        return infinicore.lcm(*args, **kwargs)
+
+
+def main():
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/lgamma.py

@@ -0,0 +1,75 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import infinicore
+import torch
+from framework import BaseOperatorTest, GenericTestRunner, TensorSpec, TestCase
+
+_TEST_CASES_DATA = [
+    ((13, 4), None),
+    ((2, 3, 4), None),
+    ((16, 5632), None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float32: {"atol": 1e-4, "rtol": 1e-4},
+}
+
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            input_spec = TensorSpec.from_tensor(shape, strides, dtype, name="input")
+            out_spec = TensorSpec.from_tensor(shape, None, dtype, name="out")
+            tolerance = _TOLERANCE_MAP[dtype]
+
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec],
+                    kwargs={},
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tolerance,
+                    description="lgamma - OUT_OF_PLACE",
+                )
+            )
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec],
+                    kwargs={},
+                    output_spec=out_spec,
+                    comparison_target="out",
+                    tolerance=tolerance,
+                    description="lgamma - INPLACE(out)",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    def __init__(self):
+        super().__init__("Lgamma")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.lgamma(*args, **kwargs)
+
+    def infinicore_operator(self, *args, **kwargs):
+        return infinicore.lgamma(*args, **kwargs)
+
+
+def main():
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()