# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_pywrap_xla', [dirname(__file__)])
        except ImportError:
            import _pywrap_xla
            return _pywrap_xla
        if fp is not None:
            try:
                _mod = imp.load_module('_pywrap_xla', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _pywrap_xla = swig_import_helper()
    del swig_import_helper
else:
    import _pywrap_xla
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def InitializeReplicaCount(replica_count):
    return _pywrap_xla.InitializeReplicaCount(replica_count)
InitializeReplicaCount = _pywrap_xla.InitializeReplicaCount

def InitializePlatformName(platform_name):
    return _pywrap_xla.InitializePlatformName(platform_name)
InitializePlatformName = _pywrap_xla.InitializePlatformName

def GetReplicaCount():
    return _pywrap_xla.GetReplicaCount()
GetReplicaCount = _pywrap_xla.GetReplicaCount

def TransferToInfeedLocal(literal):
    return _pywrap_xla.TransferToInfeedLocal(literal)
TransferToInfeedLocal = _pywrap_xla.TransferToInfeedLocal

def TransferToInfeedLocalReplica(literal, replica_number):
    return _pywrap_xla.TransferToInfeedLocalReplica(literal, replica_number)
TransferToInfeedLocalReplica = _pywrap_xla.TransferToInfeedLocalReplica

def TransferFromOutfeedLocalReplica(shape, replica_number):
    return _pywrap_xla.TransferFromOutfeedLocalReplica(shape, replica_number)
TransferFromOutfeedLocalReplica = _pywrap_xla.TransferFromOutfeedLocalReplica
class LocalShapedBuffer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalShapedBuffer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocalShapedBuffer, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["FromLiteral"] = lambda x: _pywrap_xla.LocalShapedBuffer_FromLiteral
    if _newclass:
        FromLiteral = staticmethod(_pywrap_xla.LocalShapedBuffer_FromLiteral)

    def ToLiteral(self):
        return _pywrap_xla.LocalShapedBuffer_ToLiteral(self)

    def shape(self):
        return _pywrap_xla.LocalShapedBuffer_shape(self)
    __swig_destroy__ = _pywrap_xla.delete_LocalShapedBuffer
    __del__ = lambda self: None
LocalShapedBuffer_swigregister = _pywrap_xla.LocalShapedBuffer_swigregister
LocalShapedBuffer_swigregister(LocalShapedBuffer)

def LocalShapedBuffer_FromLiteral(argument, shape_with_layout):
    return _pywrap_xla.LocalShapedBuffer_FromLiteral(argument, shape_with_layout)
LocalShapedBuffer_FromLiteral = _pywrap_xla.LocalShapedBuffer_FromLiteral

class LocalShapedBufferTuple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalShapedBufferTuple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocalShapedBufferTuple, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Release(self, i):
        return _pywrap_xla.LocalShapedBufferTuple_Release(self, i)

    def size(self):
        return _pywrap_xla.LocalShapedBufferTuple_size(self)
LocalShapedBufferTuple_swigregister = _pywrap_xla.LocalShapedBufferTuple_swigregister
LocalShapedBufferTuple_swigregister(LocalShapedBufferTuple)


def DestructureLocalShapedBufferTuple(local_shaped_buffer):
    return _pywrap_xla.DestructureLocalShapedBufferTuple(local_shaped_buffer)
DestructureLocalShapedBufferTuple = _pywrap_xla.DestructureLocalShapedBufferTuple
class XrtAllocation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XrtAllocation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XrtAllocation, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["FromLiteral"] = lambda x: _pywrap_xla.XrtAllocation_FromLiteral
    if _newclass:
        FromLiteral = staticmethod(_pywrap_xla.XrtAllocation_FromLiteral)

    def ToLiteral(self):
        return _pywrap_xla.XrtAllocation_ToLiteral(self)

    def shape(self):
        return _pywrap_xla.XrtAllocation_shape(self)
XrtAllocation_swigregister = _pywrap_xla.XrtAllocation_swigregister
XrtAllocation_swigregister(XrtAllocation)

def XrtAllocation_FromLiteral(argument, session_target):
    return _pywrap_xla.XrtAllocation_FromLiteral(argument, session_target)
XrtAllocation_FromLiteral = _pywrap_xla.XrtAllocation_FromLiteral

class XrtAllocationTuple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XrtAllocationTuple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XrtAllocationTuple, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Release(self, i):
        return _pywrap_xla.XrtAllocationTuple_Release(self, i)

    def size(self):
        return _pywrap_xla.XrtAllocationTuple_size(self)
XrtAllocationTuple_swigregister = _pywrap_xla.XrtAllocationTuple_swigregister
XrtAllocationTuple_swigregister(XrtAllocationTuple)


def DestructureXrtAllocationTuple(allocation, session_target):
    return _pywrap_xla.DestructureXrtAllocationTuple(allocation, session_target)
DestructureXrtAllocationTuple = _pywrap_xla.DestructureXrtAllocationTuple
class CompiledLocalComputation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompiledLocalComputation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompiledLocalComputation, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Execute(self, argument_handles):
        return _pywrap_xla.CompiledLocalComputation_Execute(self, argument_handles)
    __swig_destroy__ = _pywrap_xla.delete_CompiledLocalComputation
    __del__ = lambda self: None
CompiledLocalComputation_swigregister = _pywrap_xla.CompiledLocalComputation_swigregister
CompiledLocalComputation_swigregister(CompiledLocalComputation)

class CompiledXrtComputation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompiledXrtComputation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompiledXrtComputation, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Execute(self, argument_handles):
        return _pywrap_xla.CompiledXrtComputation_Execute(self, argument_handles)
CompiledXrtComputation_swigregister = _pywrap_xla.CompiledXrtComputation_swigregister
CompiledXrtComputation_swigregister(CompiledXrtComputation)

class LocalComputation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalComputation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocalComputation, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Compile(self, argument_shapes, build_options):
        return _pywrap_xla.LocalComputation_Compile(self, argument_shapes, build_options)

    def CompileForXrt(self, argument_shapes, session_target):
        return _pywrap_xla.LocalComputation_CompileForXrt(self, argument_shapes, session_target)

    def GetSerializedProto(self):
        return _pywrap_xla.LocalComputation_GetSerializedProto(self)

    def GetReturnValueShape(self):
        return _pywrap_xla.LocalComputation_GetReturnValueShape(self)
    __swig_destroy__ = _pywrap_xla.delete_LocalComputation
    __del__ = lambda self: None
LocalComputation_swigregister = _pywrap_xla.LocalComputation_swigregister
LocalComputation_swigregister(LocalComputation)

class LocalOp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocalOp, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pywrap_xla.delete_LocalOp
    __del__ = lambda self: None
LocalOp_swigregister = _pywrap_xla.LocalOp_swigregister
LocalOp_swigregister(LocalOp)

class LocalComputationBuilder(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalComputationBuilder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocalComputationBuilder, name)
    __repr__ = _swig_repr

    def __init__(self, computation_name):
        this = _pywrap_xla.new_LocalComputationBuilder(computation_name)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def SetOpMetadata(self, metadata):
        return _pywrap_xla.LocalComputationBuilder_SetOpMetadata(self, metadata)

    def ClearOpMetadata(self):
        return _pywrap_xla.LocalComputationBuilder_ClearOpMetadata(self)

    def Build(self):
        return _pywrap_xla.LocalComputationBuilder_Build(self)

    def BuildWithRoot(self, root):
        return _pywrap_xla.LocalComputationBuilder_BuildWithRoot(self, root)

    def Parameter(self, parameter_number, shape, name):
        return _pywrap_xla.LocalComputationBuilder_Parameter(self, parameter_number, shape, name)

    def GetShape(self, operand):
        return _pywrap_xla.LocalComputationBuilder_GetShape(self, operand)

    def GetReturnValueShape(self):
        return _pywrap_xla.LocalComputationBuilder_GetReturnValueShape(self)

    def Infeed(self, shape):
        return _pywrap_xla.LocalComputationBuilder_Infeed(self, shape)

    def Outfeed(self, operand, shape, outfeed_config):
        return _pywrap_xla.LocalComputationBuilder_Outfeed(self, operand, shape, outfeed_config)

    def ConstantLiteral(self, literal):
        return _pywrap_xla.LocalComputationBuilder_ConstantLiteral(self, literal)

    def Broadcast(self, operand, broadcast_sizes):
        return _pywrap_xla.LocalComputationBuilder_Broadcast(self, operand, broadcast_sizes)

    def BroadcastInDim(self, operand, shape, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_BroadcastInDim(self, operand, shape, broadcast_dimensions)

    def Pad(self, operand, padding_value, padding_config):
        return _pywrap_xla.LocalComputationBuilder_Pad(self, operand, padding_value, padding_config)

    def Reshape(self, operand, dimensions, new_sizes):
        return _pywrap_xla.LocalComputationBuilder_Reshape(self, operand, dimensions, new_sizes)

    def Collapse(self, operand, dimensions):
        return _pywrap_xla.LocalComputationBuilder_Collapse(self, operand, dimensions)

    def CrossReplicaSum(self, operand):
        return _pywrap_xla.LocalComputationBuilder_CrossReplicaSum(self, operand)

    def Slice(self, operand, start_indices, limit_indices, strides):
        return _pywrap_xla.LocalComputationBuilder_Slice(self, operand, start_indices, limit_indices, strides)

    def SliceInDim(self, operand, start_index, limit_index, stride, dimno):
        return _pywrap_xla.LocalComputationBuilder_SliceInDim(self, operand, start_index, limit_index, stride, dimno)

    def DynamicSlice(self, operand, start_indices, slice_sizes):
        return _pywrap_xla.LocalComputationBuilder_DynamicSlice(self, operand, start_indices, slice_sizes)

    def DynamicUpdateSlice(self, operand, update, start_indices):
        return _pywrap_xla.LocalComputationBuilder_DynamicUpdateSlice(self, operand, update, start_indices)

    def ConcatInDim(self, operands, dimension):
        return _pywrap_xla.LocalComputationBuilder_ConcatInDim(self, operands, dimension)

    def SelectAndScatterWithGeneralPadding(self, operand, select, window_dimensions, window_strides, padding, source, init_value, scatter):
        return _pywrap_xla.LocalComputationBuilder_SelectAndScatterWithGeneralPadding(self, operand, select, window_dimensions, window_strides, padding, source, init_value, scatter)

    def Tuple(self, elements):
        return _pywrap_xla.LocalComputationBuilder_Tuple(self, elements)

    def GetTupleElement(self, tuple_data, index):
        return _pywrap_xla.LocalComputationBuilder_GetTupleElement(self, tuple_data, index)

    def Dot(self, lhs, rhs):
        return _pywrap_xla.LocalComputationBuilder_Dot(self, lhs, rhs)

    def DotGeneral(self, lhs, rhs, dimension_numbers):
        return _pywrap_xla.LocalComputationBuilder_DotGeneral(self, lhs, rhs, dimension_numbers)

    def ConvGeneralDilated(self, lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count):
        return _pywrap_xla.LocalComputationBuilder_ConvGeneralDilated(self, lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count)

    def ConvertElementType(self, operand, new_element_type):
        return _pywrap_xla.LocalComputationBuilder_ConvertElementType(self, operand, new_element_type)

    def BitcastConvertType(self, operand, new_element_type):
        return _pywrap_xla.LocalComputationBuilder_BitcastConvertType(self, operand, new_element_type)

    def Call(self, local_computation, operands):
        return _pywrap_xla.LocalComputationBuilder_Call(self, local_computation, operands)

    def Transpose(self, operand, permutation):
        return _pywrap_xla.LocalComputationBuilder_Transpose(self, operand, permutation)

    def Rev(self, operand, dimensions):
        return _pywrap_xla.LocalComputationBuilder_Rev(self, operand, dimensions)

    def Map(self, operands, local_computation, dimensions):
        return _pywrap_xla.LocalComputationBuilder_Map(self, operands, local_computation, dimensions)

    def Reduce(self, operand, init_value, local_computation, dimensions_to_reduce):
        return _pywrap_xla.LocalComputationBuilder_Reduce(self, operand, init_value, local_computation, dimensions_to_reduce)

    def ReduceWindowWithGeneralPadding(self, operand, init_value, local_computation, window_dimensions, window_strides, base_dilations, window_dilations, padding):
        return _pywrap_xla.LocalComputationBuilder_ReduceWindowWithGeneralPadding(self, operand, init_value, local_computation, window_dimensions, window_strides, base_dilations, window_dilations, padding)

    def RngNormal(self, mu, sigma, shape):
        return _pywrap_xla.LocalComputationBuilder_RngNormal(self, mu, sigma, shape)

    def RngUniform(self, a, b, shape):
        return _pywrap_xla.LocalComputationBuilder_RngUniform(self, a, b, shape)

    def While(self, condition, body, init):
        return _pywrap_xla.LocalComputationBuilder_While(self, condition, body, init)

    def Conditional(self, predicate, true_operand, true_computation, false_operand, false_computation):
        return _pywrap_xla.LocalComputationBuilder_Conditional(self, predicate, true_operand, true_computation, false_operand, false_computation)

    def IsConstant(self, operand):
        return _pywrap_xla.LocalComputationBuilder_IsConstant(self, operand)

    def Sort(self, operand, dimension):
        return _pywrap_xla.LocalComputationBuilder_Sort(self, operand, dimension)

    def SortKeyVal(self, keys, values, dimension):
        return _pywrap_xla.LocalComputationBuilder_SortKeyVal(self, keys, values, dimension)

    def Select(self, lhs, rhs, ehs):
        return _pywrap_xla.LocalComputationBuilder_Select(self, lhs, rhs, ehs)

    def Clamp(self, lhs, rhs, ehs):
        return _pywrap_xla.LocalComputationBuilder_Clamp(self, lhs, rhs, ehs)

    def Eq(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Eq(self, lhs, rhs, broadcast_dimensions)

    def Ne(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Ne(self, lhs, rhs, broadcast_dimensions)

    def Ge(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Ge(self, lhs, rhs, broadcast_dimensions)

    def Gt(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Gt(self, lhs, rhs, broadcast_dimensions)

    def Lt(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Lt(self, lhs, rhs, broadcast_dimensions)

    def Le(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Le(self, lhs, rhs, broadcast_dimensions)

    def Add(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Add(self, lhs, rhs, broadcast_dimensions)

    def Sub(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Sub(self, lhs, rhs, broadcast_dimensions)

    def Mul(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Mul(self, lhs, rhs, broadcast_dimensions)

    def Div(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Div(self, lhs, rhs, broadcast_dimensions)

    def Rem(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Rem(self, lhs, rhs, broadcast_dimensions)

    def Max(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Max(self, lhs, rhs, broadcast_dimensions)

    def Min(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Min(self, lhs, rhs, broadcast_dimensions)

    def And(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_And(self, lhs, rhs, broadcast_dimensions)

    def Or(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Or(self, lhs, rhs, broadcast_dimensions)

    def Xor(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Xor(self, lhs, rhs, broadcast_dimensions)

    def ShiftLeft(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_ShiftLeft(self, lhs, rhs, broadcast_dimensions)

    def ShiftRightArithmetic(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_ShiftRightArithmetic(self, lhs, rhs, broadcast_dimensions)

    def ShiftRightLogical(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_ShiftRightLogical(self, lhs, rhs, broadcast_dimensions)

    def Atan2(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Atan2(self, lhs, rhs, broadcast_dimensions)

    def Pow(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Pow(self, lhs, rhs, broadcast_dimensions)

    def Complex(self, lhs, rhs, broadcast_dimensions):
        return _pywrap_xla.LocalComputationBuilder_Complex(self, lhs, rhs, broadcast_dimensions)

    def Not(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Not(self, operand)

    def Abs(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Abs(self, operand)

    def Exp(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Exp(self, operand)

    def Expm1(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Expm1(self, operand)

    def Floor(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Floor(self, operand)

    def Ceil(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Ceil(self, operand)

    def Round(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Round(self, operand)

    def Log(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Log(self, operand)

    def Log1p(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Log1p(self, operand)

    def Sign(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Sign(self, operand)

    def Cos(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Cos(self, operand)

    def Sin(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Sin(self, operand)

    def Tanh(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Tanh(self, operand)

    def IsFinite(self, operand):
        return _pywrap_xla.LocalComputationBuilder_IsFinite(self, operand)

    def Neg(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Neg(self, operand)

    def Sqrt(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Sqrt(self, operand)

    def Rsqrt(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Rsqrt(self, operand)

    def Square(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Square(self, operand)

    def Reciprocal(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Reciprocal(self, operand)

    def Erfc(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Erfc(self, operand)

    def Erf(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Erf(self, operand)

    def ErfInv(self, operand):
        return _pywrap_xla.LocalComputationBuilder_ErfInv(self, operand)

    def Lgamma(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Lgamma(self, operand)

    def Digamma(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Digamma(self, operand)

    def Acos(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Acos(self, operand)

    def Asin(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Asin(self, operand)

    def Atan(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Atan(self, operand)

    def Tan(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Tan(self, operand)

    def Acosh(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Acosh(self, operand)

    def Asinh(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Asinh(self, operand)

    def Atanh(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Atanh(self, operand)

    def Cosh(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Cosh(self, operand)

    def Sinh(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Sinh(self, operand)

    def Real(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Real(self, operand)

    def Imag(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Imag(self, operand)

    def Conj(self, operand):
        return _pywrap_xla.LocalComputationBuilder_Conj(self, operand)
    __swig_destroy__ = _pywrap_xla.delete_LocalComputationBuilder
    __del__ = lambda self: None
LocalComputationBuilder_swigregister = _pywrap_xla.LocalComputationBuilder_swigregister
LocalComputationBuilder_swigregister(LocalComputationBuilder)


def DeleteLocalShapedBuffer(local_shaped_buffer):
    return _pywrap_xla.DeleteLocalShapedBuffer(local_shaped_buffer)
DeleteLocalShapedBuffer = _pywrap_xla.DeleteLocalShapedBuffer

def DeleteXrtAllocation(allocation):
    return _pywrap_xla.DeleteXrtAllocation(allocation)
DeleteXrtAllocation = _pywrap_xla.DeleteXrtAllocation

def DeleteCompiledLocalComputation(computation):
    return _pywrap_xla.DeleteCompiledLocalComputation(computation)
DeleteCompiledLocalComputation = _pywrap_xla.DeleteCompiledLocalComputation

def DeleteCompiledXrtComputation(computation):
    return _pywrap_xla.DeleteCompiledXrtComputation(computation)
DeleteCompiledXrtComputation = _pywrap_xla.DeleteCompiledXrtComputation

def DeleteLocalComputation(computation):
    return _pywrap_xla.DeleteLocalComputation(computation)
DeleteLocalComputation = _pywrap_xla.DeleteLocalComputation
# This file is compatible with both classic and new-style classes.


