Returns an integer array that contains the default values for all the
texture parameters.

@return an integer array that contains the default values for all the
texture parameters.
187327
public int[] getDefalutValuesArray() {
        int[] defaultValues = new int[5];

        defaultValues[0] = GLES20.GL_LINEAR_MIPMAP_NEAREST; // MIN FILTER
        defaultValues[1] = GLES20.GL_LINEAR; // MAG FILTER
        defaultValues[2] = 1; // ANISO FILTER
        defaultValues[3] = GLES20.GL_CLAMP_TO_EDGE; // WRAP S
        defaultValues[4] = GLES20.GL_CLAMP_TO_EDGE; // WRAP T

        return defaultValues;
    }
101095
public function getDefaultValue()
    {
        if ($this->isArray() || $this->isList()) {
            return [];
        }
        return Utils::getValueWithinItsType($this->getMetaValueFirstSet([
            'default',
            'Default',
            'DefaultValue',
            'defaultValue',
            'defaultvalue',
        ]), $this->getType(true));
    }
552750
public String[] getOptions() {
    int       	i;
    Vector    	result;
    String	tmpStr;

    result = new Vector();

    for (i = 0; i < m_Parameters.length; i++) {
      result.add("-search");
      tmpStr =   m_Parameters[i].getClass().getName() + " "
               + Utils.joinOptions(m_Parameters[i].getOptions());
      result.add(tmpStr);
    }

    return (String[]) result.toArray(new String[result.size()]);
  }
953977
function getTextureTypeForArrayType(gl, src, defaultType) {
  if (isArrayBuffer(src)) {
    return typedArrays.getGLTypeForTypedArray(src);
  }
  return defaultType || gl.UNSIGNED_BYTE;
}
15820
public function getDefaultValues()
    {
        $values = [];
        foreach ($this->getColumns() as $column) {
            $values[$column->getName()] = $column->getDefaultValue();
        }
        return $values;
    }
1260766
public JClass []getParameterTypes()
  {
    Class []types = _method.getParameterTypes();

    JClass []jTypes = new JClass[types.length];

    for (int i = 0; i < types.length; i++) {
      jTypes[i] = _loader.forName(types[i].getName());
    }

    return jTypes;
  }
101816
public Parameter[] parameters() {
        // generate the parameters on the fly:  they're not cached
        List<VarSymbol> params = sym.params();
        Parameter result[] = new Parameter[params.length()];

        int i = 0;
        for (VarSymbol param : params) {
            result[i++] = new ParameterImpl(env, param);
        }
        return result;
    }
1142199
public static function availableDefaultValues()
    {
        return [
            self::DEFAULT_NULL,
            self::DEFAULT_OUT_OF_BOUNDS,
            self::DEFAULT_NOT_DERIVABLE,
            self::DEFAULT_NOT_GIVEN,
            self::DEFAULT_NOT_ASKED,
            self::DEFAULT_NOT_PERMITTED,
        ];
    }
793963
protected int[] getArgTypes() {
		// { Types.CHAR, Types.VARCHAR, Types.TIMESTAMP, Types.VARCHAR };
		int[] valuesTypes = new int[type.size()];
		Object[] types = type.toArray();
		for (int i = 0; i < types.length; i++) {
			valuesTypes[i] = this.getIntType(i);
		}
		return valuesTypes;
	}
19082
public AnnotationParameterValueList getParameterValues() {
        if (annotationParamValuesWithDefaults == null) {
            final ClassInfo classInfo = getClassInfo();
            if (classInfo == null) {
                // ClassInfo has not yet been set, just return values without defaults
                // (happens when trying to log AnnotationInfo during scanning, before ScanResult is available)
                return annotationParamValues == null ? AnnotationParameterValueList.EMPTY_LIST
                        : annotationParamValues;
            }

            // Lazily convert any Object[] arrays of boxed types to primitive arrays
            if (annotationParamValues != null && !annotationParamValuesHasBeenConvertedToPrimitive) {
                annotationParamValues.convertWrapperArraysToPrimitiveArrays(classInfo);
                annotationParamValuesHasBeenConvertedToPrimitive = true;
            }
            if (classInfo.annotationDefaultParamValues != null
                    && !classInfo.annotationDefaultParamValuesHasBeenConvertedToPrimitive) {
                classInfo.annotationDefaultParamValues.convertWrapperArraysToPrimitiveArrays(classInfo);
                classInfo.annotationDefaultParamValuesHasBeenConvertedToPrimitive = true;
            }

            // Check if one or both of the defaults and the values in this annotation instance are null (empty)
            final AnnotationParameterValueList defaultParamValues = classInfo.annotationDefaultParamValues;
            if (defaultParamValues == null && annotationParamValues == null) {
                return AnnotationParameterValueList.EMPTY_LIST;
            } else if (defaultParamValues == null) {
                return annotationParamValues;
            } else if (annotationParamValues == null) {
                return defaultParamValues;
            }

            // Overwrite defaults with non-defaults
            final Map<String, Object> allParamValues = new HashMap<>();
            for (final AnnotationParameterValue defaultParamValue : defaultParamValues) {
                allParamValues.put(defaultParamValue.getName(), defaultParamValue.getValue());
            }
            for (final AnnotationParameterValue annotationParamValue : this.annotationParamValues) {
                allParamValues.put(annotationParamValue.getName(), annotationParamValue.getValue());
            }

            // Put annotation values in the same order as the annotation methods (there is one method for each
            // annotation constant)
            if (classInfo.methodInfo == null) {
                // Should not happen (when classfile is read, methods are always read, whether or not
                // scanSpec.enableMethodInfo is true)
                throw new IllegalArgumentException("Could not find methods for annotation " + classInfo.getName());
            }
            annotationParamValuesWithDefaults = new AnnotationParameterValueList();
            for (final MethodInfo mi : classInfo.methodInfo) {
                final String paramName = mi.getName();
                switch (paramName) {
                // None of these method names should be present in the @interface class itself, it should only
                // contain methods for the annotation constants (but skip them anyway to be safe). These methods
                // should only exist in concrete instances of the annotation.
                case "<init>":
                case "<clinit>":
                case "hashCode":
                case "equals":
                case "toString":
                case "annotationType":
                    // Skip
                    break;
                default:
                    // Annotation constant
                    final Object paramValue = allParamValues.get(paramName);
                    // Annotation values cannot be null (or absent, from either defaults or annotation instance)
                    if (paramValue != null) {
                        annotationParamValuesWithDefaults.add(new AnnotationParameterValue(paramName, paramValue));
                    }
                    break;
                }
            }
        }
        return annotationParamValuesWithDefaults;
    }
914168
public AbstractInsnNode[] toArray() {
        int i = 0;
        AbstractInsnNode elem = first;
        AbstractInsnNode[] insns = new AbstractInsnNode[size];
        while (elem != null) {
            insns[i] = elem;
            elem.index = i++;
            elem = elem.next;
        }
        return insns;
    }
539557
public V[] getValues() {
		final V[] array = factory.newArray(elementCount);
		int i = 0;
		for (final V v : this) {
			array[i++] = v;
		}
		return array;
	}
145901
public List<InitParamType<PortletType<T>>> getAllInitParam()
   {
      List<InitParamType<PortletType<T>>> list = new ArrayList<InitParamType<PortletType<T>>>();
      List<Node> nodeList = childNode.get("init-param");
      for(Node node: nodeList)
      {
         InitParamType<PortletType<T>>  type = new InitParamTypeImpl<PortletType<T>>(this, "init-param", childNode, node);
         list.add(type);
      }
      return list;
   }
1292965
public int[] getCurrentValuesArray() {
        int[] currentValues = new int[5];

        currentValues[0] = getMinFilterType().getFilterValue(); // MIN FILTER
        currentValues[1] = getMagFilterType().getFilterValue(); // MAG FILTER
        currentValues[2] = getAnisotropicValue(); // ANISO FILTER
        currentValues[3] = getWrapSType().getWrapValue(); // WRAP S
        currentValues[4] = getWrapTType().getWrapValue(); // WRAP T

        return currentValues;
    }
216046
@Override
    public Object[] getParameters() {
        // return the parameters as used for the descriptor calculation
        Object[] params = new Object[1];
        params[0] = (Integer) maxIterations;
        return params;
    }
738263
public int[] getValues() {
        int[] graylevel = new int[size];
        int[] values1D = convertToArray();
        for( int i = 0; i < size; i++ ) {
            graylevel[i] = values1D[i] & 0x000000ff;
        }
        return graylevel;
    }
394960
def _getDefaultCombinedL4Params(self, numInputBits, inputSize,
                                  numExternalInputBits, externalInputSize,
                                  L2CellCount):
    
    sampleSize = numExternalInputBits + numInputBits
    activationThreshold = int(max(numExternalInputBits, numInputBits) * .6)
    minThreshold = activationThreshold

    return {
      "columnCount": inputSize,
      "cellsPerColumn": 16,
      "learn": True,
      "learnOnOneCell": False,
      "initialPermanence": 0.41,
      "connectedPermanence": 0.6,
      "permanenceIncrement": 0.1,
      "permanenceDecrement": 0.02,
      "minThreshold": minThreshold,
      "basalPredictedSegmentDecrement": 0.001,
      "apicalPredictedSegmentDecrement": 0.0,
      "reducedBasalThreshold": int(activationThreshold*0.6),
      "activationThreshold": activationThreshold,
      "sampleSize": sampleSize,
      "implementation": "ApicalTiebreak",
      "seed": self.seed,
      "basalInputWidth": inputSize*16 + externalInputSize,
      "apicalInputWidth": L2CellCount,
    }