Returns a deep copy of the number instance. When *nominal* or *uncertainties* are set, they
        overwrite the fields of the copied instance.
353976
def copy(self, nominal=None, uncertainties=None):
        
        if nominal is None:
            nominal = self.nominal
        if uncertainties is None:
            uncertainties = self.uncertainties
        return self.__class__(nominal, uncertainties=uncertainties)
817776
def copy(self):
        
        return self.__class__(self.x, self.y, *self._args, **self._kwargs)
438120
def get_numeric_data(self, copy=False):
        
        self._consolidate_inplace()
        return self.combine([b for b in self.blocks if b.is_numeric], copy)
1355445
def duplicate(self):
        '''
        
        '''
        return self.__class__(amount=self.amount, date=self.date,
                              method=self.method, ref=self.ref)
1146209
def copy(self):
    ''''''
    if self.object_getattr is Query.object_getattr:
      other = Query(self.key)
    else:
      other = Query(self.key, object_getattr=self.object_getattr)
    other.limit = self.limit
    other.offset = self.offset
    other.offset_key = self.offset_key
    other.filters = self.filters
    other.orders = self.orders
    return other
821374
def copy(self):
        
        o = SimLibrary()
        o.procedures = dict(self.procedures)
        o.non_returning = set(self.non_returning)
        o.prototypes = dict(self.prototypes)
        o.default_ccs = dict(self.default_ccs)
        o.names = list(self.names)
        return o
784569
def copy(self):
        ""
        other = _ChainedHashAlgorithm(self._algorithms)
        other._hobj = deepcopy(self._hobj)
        other._fobj = deepcopy(self._fobj)
        return other
724840
def copy(self):
        
        copyClass = self.copyClass
        if copyClass is None:
            copyClass = self.__class__
        copied = copyClass()
        copied.copyData(self)
        return copied
1327771
def clone(self):
        
        from copy import copy
        clone = copy(self)
        clone.expr = copy(self.expr)
        clone.factory = False
        return clone
812508
def copy(self):
        
        np = Particle()
        memmove(byref(np), byref(self), sizeof(self))
        return np
607829
def copy(self):
        """"""
        if self._pre_computed_hash is None:
            temp = ssdeep(buf="")
        else:
            temp = ssdeep(hash=hash)
        libssdeep_wrapper.fuzzy_free(temp._state)
        temp._state = libssdeep_wrapper.fuzzy_clone(self._state)
        temp._updatable = self._updatable
        temp._pre_computed_hash = self._pre_computed_hash
        return temp
845723
def copy(self):
        

        vs = ValueSet(bits=self.bits)
        vs._regions = self._regions.copy()
        vs._region_base_addrs = self._region_base_addrs.copy()
        vs._reversed = self._reversed
        vs._si = self._si.copy()

        return vs
301980
def initialize_copy(original)
      instance_variables.each do |ivar|
        instance_variable_set(ivar, DataMapper::Ext.try_dup(instance_variable_get(ivar)))
      end

      self.persistence_state = persistence_state.class.new(self)
    end
238492
def copy(self):
        
        # New dummy item with it's own running properties
        copied_item = self.__class__({})
        # Now, copy the properties
        for prop in self.__class__.properties:
            if prop in ['uuid']:
                continue
            val = getattr(self, prop, None)
            if val is not None:
                setattr(copied_item, prop, val)

        # Also copy some running properties
        # The custom variables
        if hasattr(self, "customs"):
            copied_item.customs = copy(self.customs)
        # And tags/templates
        if hasattr(self, "tags"):
            copied_item.tags = copy(self.tags)
        if hasattr(self, "templates"):
            copied_item.templates = copy(self.templates)

        return copied_item
738873
def copy(n = 1)
      raise ArgumentError, 'n must be a non-negative Integer' if not n.is_a?(::Integer) or n < 0
      return self if n == 1
      return Erlang::Binary[(@data * n)]
    end
561434
def copyWithoutMathSubObjects(self):
        
        n = MathGlyph(None)
        n.name = self.name
        if self.unicodes is not None:
            n.unicodes = list(self.unicodes)
        n.width = self.width
        n.height = self.height
        n.note = self.note
        n.lib = deepcopy(dict(self.lib))
        return n
1098189
def copy(self):
        
        state_copy = State()
        state_copy._state_dict = copy.deepcopy(self._state_dict)
        return state_copy