import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda


@triton.jit
def triton_poi_fused__to_copy_add_cos_div_exp_lt_mul_neg_pow_sub_0(in_ptr0,
    in_ptr1, in_ptr2, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 12800
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x1 = xindex // 50
    x0 = xindex % 50
    x2 = xindex
    tmp0 = tl.load(in_ptr0 + x1, xmask, eviction_policy='evict_last')
    tmp14 = tl.load(in_ptr1 + x0, xmask, eviction_policy='evict_last')
    tmp21 = tl.load(in_ptr2 + x0, xmask, eviction_policy='evict_last')
    tmp1 = 3.141592653589793
    tmp2 = tmp0 * tmp1
    tmp3 = 0.2
    tmp4 = tmp2 * tmp3
    tmp5 = tl_math.cos(tmp4)
    tmp6 = 1.0
    tmp7 = tmp5 + tmp6
    tmp8 = 0.5
    tmp9 = tmp7 * tmp8
    tmp10 = 5.0
    tmp11 = tmp0 < tmp10
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp9 * tmp12
    tmp15 = -tmp14
    tmp16 = -tmp0
    tmp17 = 0.0
    tmp18 = tmp16 + tmp17
    tmp19 = tmp18 * tmp6
    tmp20 = tl_math.exp(tmp19)
    tmp22 = tmp20 - tmp21
    tmp23 = tmp22 * tmp22
    tmp24 = tmp15 * tmp23
    tmp25 = tl_math.exp(tmp24)
    tmp26 = tmp13 * tmp25
    tl.store(out_ptr0 + x2, tmp26, xmask)


def call(args):
    primals_1, primals_2, primals_3 = args
    args.clear()
    assert_size_stride(primals_1, (4, 4, 4, 4), (64, 16, 4, 1))
    assert_size_stride(primals_2, (50,), (1,))
    assert_size_stride(primals_3, (50,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, 4, 4, 4, 50), (3200, 800, 200, 50, 1),
            torch.float32)
        get_raw_stream(0)
        triton_poi_fused__to_copy_add_cos_div_exp_lt_mul_neg_pow_sub_0[grid
            (12800)](primals_1, primals_2, primals_3, buf0, 12800, XBLOCK=
            256, num_warps=4, num_stages=1)
    return buf0, primals_1, primals_2, primals_3


class CosineCutoff(nn.Module):

    def __init__(self, cutoff_lower=0.0, cutoff_upper=5.0):
        super(CosineCutoff, self).__init__()
        self.cutoff_lower = cutoff_lower
        self.cutoff_upper = cutoff_upper

    def forward(self, distances):
        if self.cutoff_lower > 0:
            cutoffs = 0.5 * (torch.cos(math.pi * (2 * (distances - self.
                cutoff_lower) / (self.cutoff_upper - self.cutoff_lower) + 
                1.0)) + 1.0)
            cutoffs = cutoffs * (distances < self.cutoff_upper).float()
            cutoffs = cutoffs * (distances > self.cutoff_lower).float()
            return cutoffs
        else:
            cutoffs = 0.5 * (torch.cos(distances * math.pi / self.
                cutoff_upper) + 1.0)
            cutoffs = cutoffs * (distances < self.cutoff_upper).float()
            return cutoffs


class ExpNormalSmearingNew(nn.Module):

    def __init__(self, cutoff_lower=0.0, cutoff_upper=5.0, num_rbf=50,
        trainable=True):
        super(ExpNormalSmearingNew, self).__init__()
        self.cutoff_lower = cutoff_lower
        self.cutoff_upper = cutoff_upper
        self.num_rbf = num_rbf
        self.trainable = trainable
        self.cutoff_fn = CosineCutoff(0, cutoff_upper)
        self.alpha = 5.0 / (cutoff_upper - cutoff_lower)
        means, betas = self._initial_params()
        if trainable:
            self.register_parameter('means', nn.Parameter(means))
            self.register_parameter('betas', nn.Parameter(betas))
        else:
            self.register_buffer('means', means)
            self.register_buffer('betas', betas)

    def _initial_params(self):
        start_value = torch.exp(torch.scalar_tensor(-self.cutoff_upper +
            self.cutoff_lower))
        means = torch.linspace(start_value, 1, self.num_rbf)
        betas = torch.tensor([(2 / self.num_rbf * (1 - start_value)) ** -2] *
            self.num_rbf)
        return means, betas

    def reset_parameters(self):
        means, betas = self._initial_params()
        self.means.data.copy_(means)
        self.betas.data.copy_(betas)

    def forward(self, input_0):
        primals_2 = self.means
        primals_3 = self.betas
        primals_1 = input_0
        output = call([primals_1, primals_2, primals_3])
        return output[0]


Measured latency_ms: 0.015791