Get or create a constant from the constant pool representing an array
class.

@param dim Number of array dimensions.
162850
public ConstantClassInfo addConstantClass(String className, int dim) {
        return (ConstantClassInfo)addConstant(new ConstantClassInfo(this, className, dim));
    }
325432
def get_free_dims(model, visible_dims, fixed_dims):
    
    if visible_dims is None:
        visible_dims = np.arange(model.input_dim)
    dims = np.asanyarray(visible_dims)
    if fixed_dims is not None:
        dims = [dim for dim in dims if dim not in fixed_dims]
    return np.asanyarray([dim for dim in dims if dim is not None])
1063139
public final void setDimAmount(final float dimAmount) {
        Condition.INSTANCE.ensureAtLeast(dimAmount, 0, "The dim amount must be at least 0");
        Condition.INSTANCE.ensureAtMaximum(dimAmount, 1, "The dim amount must be at maximum 1");
        this.dimAmount = dimAmount;
        getWindow().getAttributes().dimAmount = dimAmount;
    }
3277
def red_dim(self, array):
        
        while isinstance(array, list) == True or \
        isinstance(array, np.ndarray) == True:
            try:
                if len(array) == 1:
                    array = array[0]
                else:
                    break
            except:
                break

        return array
78330
public static int size(DataBuffer buffer, int dimension) {
        int rank = rank(buffer);
        if (dimension >= rank)
            throw new IllegalArgumentException("Invalid dimension " + dimension + " for rank " + rank + " array");
        return buffer.getInt(1 + dimension);
    }
484789
def get(self,dimlist):
        '''
        
        '''
        out=()
        for i,d in enumerate(dimlist):
            out+=(super(dimStr, self).get(d,None),)
         
        return out
1307845
public static List<Class<?>> makeArrayClasses(List<Class<?>> classes, int dims)
    {
        Iterator<Class<?>> i = classes.iterator();
        LinkedList<Class<?>> arrayClasses = new LinkedList<Class<?>>();
        while(i.hasNext())
            arrayClasses.add(makeArrayClass(i.next(), dims));
        return arrayClasses;
    }
858184
private static int[] getDims(VarSet vars) {
        int[] dims = new int[vars.size()];
        for (int i=0; i<vars.size(); i++) {
            dims[i] = vars.get(i).getNumStates();
        }
        return dims;
    }
1138606
@Override
	public Number getValue(ValueDimension dim, int index) {
		return values.get(dim).get(index);
	}
439197
public function getDimensionLabel($dim)
    {
        switch ($dim) {
            case self::DIM_WIDTH:
                return _t(__CLASS__ . '.WIDTH', 'Width');
            case self::DIM_HEIGHT:
                return _t(__CLASS__ . '.HEIGHT', 'Height');
        }
    }
466517
public void insert(final long[] argin, final int dim_x, final int dim_y) {
	attrval.r_dim.dim_x = dim_x;
	attrval.r_dim.dim_y = dim_y;
	DevVarLong64ArrayHelper.insert(attrval.value, argin);
    }
500265
public static TableModel fromCSP(CSProperties p, final int dim) {
        List<String> dims = keysByMeta(p, "role", "dimension");
        if (dims.isEmpty()) {
            return null;
        }
        for (String d : dims) {
            if (Integer.parseInt(p.get(d).toString()) == dim) {
                final List<String> bounds = keysByMeta(p, "bound", d);
                final List<Object> columns = new ArrayList<Object>(bounds.size());
                for (String bound : bounds) {
                    columns.add(Conversions.convert(p.get(bound), double[].class));
                }

                return new AbstractTableModel() {

                    @Override
                    public int getRowCount() {
                        return dim;
                    }

                    @Override
                    public int getColumnCount() {
                        return bounds.size();
                    }

                    @Override
                    public Object getValueAt(int rowIndex, int columnIndex) {
                        return Array.get(columns.get(columnIndex), rowIndex);
                    }

                    @Override
                    public String getColumnName(int column) {
                        return bounds.get(column);
                    }

                    @Override
                    public Class<?> getColumnClass(int columnIndex) {
                        return Double.class;
                    }
                };
            }
        }
        return null;
    }
48852
public ClassConstant getClass(String name)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof ClassConstant))
        continue;

      ClassConstant classEntry = (ClassConstant) entry;

      if (classEntry.getName().equals(name))
        return classEntry;
    }

    return null;
  }
297726
public static int size(IntBuffer buffer, int dimension) {
        int rank = rank(buffer);
        if (dimension >= rank)
            throw new IllegalArgumentException("Invalid dimension " + dimension + " for rank " + rank + " array");
        return buffer.get(1 + dimension);
    }
1292520
public static Object toWrapperArray(Object array) {
    if (!array.getClass().isArray()) {
      throw new IllegalArgumentException("Must give array object.");
    }
    if (isPrimitiveArray(array.getClass())) {
      int length = Array.getLength(array);
      Object newArray = Array.newInstance(toWrapper(array.getClass().getComponentType()), length);
      for (int i = 0; i < length; i++) {
        Array.set(newArray, i, toWrapper(Array.get(array, i)));
      }
      return newArray;
    } else if (array.getClass().getComponentType().isArray()) {
      int length = Array.getLength(array);
      Object newArray = Array.newInstance(toWrapperArray(array.getClass().getComponentType()), length);
      for (int i = 0; i < length; i++) {
        Array.set(newArray, i, toWrapperArray(Array.get(array, i)));
      }
      return newArray;
    }
    return array;
  }
155030
def p_class_constant(p):
    ''''''
    p[0] = ast.StaticProperty(p[1], p[3], lineno=p.lineno(2))
652391
public void insert(final int[] argin, final int dim_x, final int dim_y) {
	attrval.r_dim.dim_x = dim_x;
	attrval.r_dim.dim_y = dim_y;
	DevVarLongArrayHelper.insert(attrval.value, argin);
    }