Sets default parameters for KLU.

@param Common
@return
774384
public static int klu_defaults(KLU_common Common)
	{
		if (Common == null)
		{
			return (FALSE) ;
		}

		/* parameters */
		Common.tol = 0.001 ;       /* pivot tolerance for diagonal */
		Common.memgrow = 1.2 ;     /* realloc size ratio increase for LU factors */
		Common.initmem_amd = 1.2 ; /* init. mem with AMD:  c*nnz(L) + n */
		Common.initmem = 10 ;      /* init. mem otherwise: c*nnz(A) + n */
		Common.btf = TRUE ;        /* use BTF pre-ordering, or not */
		Common.maxwork = 0 ;       /* no limit to work done by btf_order */
		Common.ordering = 0 ;      /* 0: AMD, 1: COLAMD, 2: user-provided P and Q,
		                            * 3: user-provided function */
		Common.scale = 2 ;         /* scale: -1: none, and do not check for errors
		                            * in the input matrix in KLU_refactor.
		                            * 0: none, but check for errors,
		                            * 1: sum, 2: max */
		Common.halt_if_singular = TRUE ;   /* quick halt if matrix is singular */

		/* memory management routines */
		//Common.malloc_memory  = malloc ;
		//Common.calloc_memory  = calloc ;
		//Common.free_memory    = free ;
		//Common.realloc_memory = realloc ;

		/* user ordering function and optional argument */
		Common.user_order = null ;
		Common.user_data = null ;

		/* statistics */
		Common.status = KLU_OK ;
		Common.nrealloc = 0 ;
		Common.structural_rank = EMPTY ;
		Common.numerical_rank = EMPTY ;
		Common.noffdiag = EMPTY ;
		Common.flops = EMPTY ;
		Common.rcond = EMPTY ;
		Common.condest = EMPTY ;
		Common.rgrowth = EMPTY ;
		Common.work = 0 ;          /* work done by btf_order */

		Common.memusage = 0 ;
		Common.mempeak = 0 ;

		return (TRUE) ;
	}
1161442
@Override
    public Map<String, String> createDefaultOptions() {
        HashMap<String, String> ret = new HashMap<String, String>();
        // Add any default options needed here (like path to default properties)

        ret.put("client", "client.properties");

        return ret;
    }
129321
protected Object common_put(Object key, Object value, int priority, int timeToLive, int sharingPolicy, Object dependencyIds[]) {
        return common_put(key, value, priority, timeToLive, -1, sharingPolicy, dependencyIds);
    }
454629
protected KafkaQueueFactory<T, ID, DATA> setDefaultKafkaClient(KafkaClient kafkaClient,
            boolean setMyOwnKafkaClient) {
        if (this.defaultKafkaClient != null && myOwnKafkaClient) {
            this.defaultKafkaClient.destroy();
        }
        this.defaultKafkaClient = kafkaClient;
        myOwnKafkaClient = setMyOwnKafkaClient;
        return this;
    }
1371326
def select_common_params(from:)
      return from if @common_params.empty?
      from.select {|k,v| valid_common_param?(k)}
    end
315171
def set_global_defaults(**kwargs):
    """"""

    valid_options = [
        'active', 'selected', 'disabled', 'on', 'off',
        'on_active', 'on_selected', 'on_disabled',
        'off_active', 'off_selected', 'off_disabled',
        'color', 'color_on', 'color_off',
        'color_active', 'color_selected', 'color_disabled',
        'color_on_selected', 'color_on_active', 'color_on_disabled',
        'color_off_selected', 'color_off_active', 'color_off_disabled',
        'animation', 'offset', 'scale_factor',
        ]

    for kw in kwargs:
        if kw in valid_options:
            _default_options[kw] = kwargs[kw]
        else:
            error = "Invalid option '{0}'".format(kw)
            raise KeyError(error)
1319553
public void setDefaultNamedOutput(OutputFormat outputFormat, Class keyClass, Class valueClass, Map<String, String> specificContext)  throws TupleMRException {
  	namedOutputs.add(new Output(true, "DEFAULT", outputFormat, keyClass, valueClass, specificContext));
  }
1356260
void setDefaults() {
        // If no ClassLoaders are specified, use the TCCL
        // Ensure we default this BEFORE defaulting the extension loader, as
        // the loader needs a CL to be created
        if (this.getClassLoaders() == null) {
            final ClassLoader tccl = SecurityActions.getThreadContextClassLoader();
            if (log.isLoggable(Level.FINER)) {
                log.finer("User has not defined an explicit " + ClassLoader.class.getSimpleName()
                    + "; defaulting to the TCCL: " + tccl);
            }
            final Collection<ClassLoader> tcclCollection = new ArrayList<ClassLoader>(1);
            // Adjust for the bootstrap CL, which may be denoted as null in some JVM impls
            if (tccl != null) {
                tcclCollection.add(tccl);
            } else {
                tcclCollection.add(ClassLoader.getSystemClassLoader());
            }
            this.classLoaders = tcclCollection;
        }

        // Adjust the CLs to be sure of no duplicate or null references (which may indicate
        // the bootstrap CL, so get to the system CL)
        final Collection<ClassLoader> adjustedCls = new HashSet<ClassLoader>();
        for (ClassLoader cl : this.classLoaders) {

            // Adjust for null references
            if (cl == null) {
                cl = ClassLoader.getSystemClassLoader();
            }

            // Add to the set, which will restrict duplicates
            adjustedCls.add(cl);
        }
        this.classLoaders = adjustedCls;

        // If no extension loader is present, create one
        if (getExtensionLoader() == null) {
            final ExtensionLoader loader = createDefaultExtensionLoader();
            if (log.isLoggable(Level.FINER)) {
                log.finer("User has not defined an explicit " + ExtensionLoader.class.getSimpleName()
                    + "; defaulting to " + loader);
            }
            this.extensionLoader(loader);
        }
    }
104808
public static <K,V> Set<K> commonKeys(Map<K,V> left, Map<K,V> right) {
        if (left == null || right == null) {
            return Collections.emptySet();
        }

        return Sets.intersection(left.keySet(),right.keySet());
    }
366196
public void setUnknownTokenBoundaries() {
       if ( children==null ) {
           if ( startIndex<0 || stopIndex<0 ) {
               startIndex = stopIndex = token.getTokenIndex();
           }
           return;
       }
       for (int i=0; i<children.size(); i++) {
           ((CommonTree)children.get(i)).setUnknownTokenBoundaries();
       }
       if ( startIndex>=0 && stopIndex>=0 ) return; // already set
       if ( children.size() > 0 ) {
           CommonTree firstChild = (CommonTree)children.get(0);
           CommonTree lastChild = (CommonTree)children.get(children.size()-1);
           startIndex = firstChild.getTokenStartIndex();
           stopIndex = lastChild.getTokenStopIndex();
       }
   }
1110919
private void applyDefaultValues(Map<String, Object> parameterValues) {
    for (Parameter<?> parameter : allParameters) {
      parameterValues.put(parameter.getName(), getParameterDefaultValue(parameter));
    }
  }
551369
public DefaultListOperation<T> set(String parameterName,
            String parameterValue) {
        queryParameters.add(parameterName, parameterValue);
        return this;
    }
1293891
public V get(K key, V defaultValue)
    {
        // Check if we only know an equal entry
        V sharedValue = get(key);

        if (sharedValue == null) {
            // If no entry can be found, store and return the passed one
            sharedValue = defaultValue;

            // Make sure to remember the entry
            put(key, defaultValue);
        }

        // Return the shared entry
        return sharedValue;
    }
934253
final protected void common_put(
                                    Object key,
                                    Object value,
                                    Object userMetaData,
                                    int priority,
                                    int timeToLive,
                                    int sharingPolicy,
                                    Object dependencyIds[],
                                    Object aliasIds[]) {
        try {
            internal_putAndGet(key, value, userMetaData, priority, timeToLive, -1, sharingPolicy, dependencyIds, aliasIds, !INCREMENT_REF_COUNT, !SKIP_MEMORY_WRITE_TO_DISK);
        } catch (DynamicCacheException ex) {
            com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.DistribtedObjectCacheAdapter", "669", this);
            if (tc.isDebugEnabled())
                Tr.debug(tc, "common_put - exception: " + ExceptionUtility.getStackTrace(ex));
        }
    }
550431
final protected Collection common_values() {
        //TODO: make efficient
        ArrayList<Object> al = new ArrayList<Object>();
        Enumeration vEnum = cache.getAllIds();
        while (vEnum.hasMoreElements())
            al.add(get(vEnum.nextElement()));
        return al;
    }
646248
protected final void doDefaults(final Map<K, ? extends V> defaults) {

        apply(defaults.isEmpty() ? Nop.instance() : new Defaults<>(defaults));

    }
255585
function setDefaultQueryParams(req, data, logger) {
    var parameters = _.toArray(data.parameters);
    for (var i = 0; i < parameters.length; i++) {
        var parm = parameters[i];
        if (parm.in === 'query') {
            if (!_.isUndefined(parm.default) && _.isUndefined(req.query[parm.name])) {
                req.query[parm.name] = swaggerUtil.cast(parm, parm.default);
            }
        }
    }
}