Make a copy of an objective. The objective being copied can be of the same type or belong to
        a different solver interface.

        Example
        ----------
        >>> new_objective = Objective.clone(old_objective)
350079
def clone(cls, objective, model=None, **kwargs):
        
        return cls(cls._substitute_variables(objective, model=model), name=objective.name,
                   direction=objective.direction, sloppy=True, **kwargs)
657308
def copy(self):
    
    self_copy = self.dup()
    self_copy._scopes = copy.copy(self._scopes)
    return self_copy
1091323
def clone(self, name=None):
    
    if name is None:
      name = self.module_name + "_clone"
    return Linear(output_size=self.output_size,
                  use_bias=self._use_bias,
                  initializers=self._initializers,
                  partitioners=self._partitioners,
                  regularizers=self._regularizers,
                  name=name)
192534
function clone (obj){
	if(obj == null || typeof(obj) != 'object')
		return obj;

	var temp = obj.constructor();

	for(var key in obj)
		temp[key] = clone(obj[key]);
	return temp;
}
1355445
def duplicate(self):
        '''
        
        '''
        return self.__class__(amount=self.amount, date=self.date,
                              method=self.method, ref=self.ref)
591209
def difference(self, other):
        

        obj = self._clone()
        obj.difference_update(other)
        return obj
267307
def copy(self):
        
        options = {
            'op': self.__op,
            'caseSensitive': self.__caseSensitive,
            'value': copy.copy(self.__value),
            'inverted': self.__inverted,
            'functions': copy.copy(self.__functions),
            'math': copy.copy(self.__math)
        }
        return orb.Query(self.__model, self.__column, **options)
303895
def duplicate(self):
        '''
        
        '''
        instance = self.__class__(name=self.name, description=self.description)
        for line in self.lines:
            instance.lines.append(line.duplicate())
        return instance
817776
def copy(self):
        
        return self.__class__(self.x, self.y, *self._args, **self._kwargs)
806709
def clone(self):
        
        self._dlog("cloning the stack")
        # TODO is this really necessary to create a brand new one?
        # I think it is... need to think about it more.
        # or... are we going to need ref counters and a global
        # scope object that allows a view into (or a snapshot of)
        # a specific scope stack?
        res = Scope(self._log)
        res._scope_stack = self._scope_stack
        res._curr_scope = self._curr_scope
        return res
1064672
def clone(self):
        

        new_solution = self.__class__(self._problem)

        # Clone routes
        for index, r in enumerate(self._routes):
            new_route = new_solution._routes[index] = models.Route(self._problem)
            for node in r.nodes():
                # Insert new node on new route
                new_node = new_solution._nodes[node.name()]
                new_route.allocate([new_node])

        # remove empty routes from new solution
        new_solution._routes = [route for route in new_solution._routes if route._nodes]
        
        return new_solution
926327
def copy(self):
        
        new_prog = self.copy_everything_except_instructions()
        new_prog._instructions = self._instructions.copy()
        return new_prog
350946
def copy(self):
        """"""
        rv = object.__new__(self.__class__)
        rv.__dict__.update(self.__dict__)
        rv.identifiers = object.__new__(self.identifiers.__class__)
        rv.identifiers.__dict__.update(self.identifiers.__dict__)
        return rv
1272149
def clone_to(target)
      raise ContainerError, "Container does not exist." unless exists?

      if LXC.container(target).exists?
        raise ContainerError, "New container already exists."
      end

      LXC.run("clone", "-o", name, "-n", target)
      LXC.container(target)
    end
876937
def copy(
            self,
            extractor=None,
            needs=None,
            store=None,
            data_writer=None,
            persistence=None,
            extractor_args=None):
        
        f = Feature(
            extractor or self.extractor,
            needs=needs,
            store=self.store if store is None else store,
            encoder=self.encoder,
            decoder=self.decoder,
            key=self.key,
            data_writer=data_writer,
            persistence=persistence,
            **(extractor_args or self.extractor_args))
        f._fixup_needs()
        return f
784569
def copy(self):
        ""
        other = _ChainedHashAlgorithm(self._algorithms)
        other._hobj = deepcopy(self._hobj)
        other._fobj = deepcopy(self._fobj)
        return other
684131
def _copy(self):
        
        args, kwargs = self._to_constructor_args(self)
        value = self.__class__(*args, **kwargs)
        value.ion_event = None
        value.ion_type = self.ion_type
        value.ion_annotations = self.ion_annotations
        return value