Returns a list of variable names that define the size of each dimension.
977896
def _ctypes_splice(parameter):
    
    params = parameter.ctypes_parameter()
    if parameter.direction == "(inout)" and ("allocatable" in parameter.modifiers or
                                             "pointer" in parameter.modifiers):
        return ', '.join(params[1:-1])
    else:
        return ', '.join(params[1::])
1351792
public java.util.List<Dimension> getDimensions() {
        if (dimensions == null) {
            dimensions = new com.amazonaws.internal.SdkInternalList<Dimension>();
        }
        return dimensions;
    }
1282448
private Variable[] getLocallyDeclaredVariables() {
        Collection<Variable> vars = mDeclared.values();
        return vars.toArray(new Variable[vars.size()]);
    }
397687
def dimensionNames(self):
        
        nSubDims = len(self._subArrayShape)
        subArrayDims = ['SubDim{}'.format(dimNr) for dimNr in range(nSubDims)]
        return dimNamesFromDataset(self._h5Dataset) + subArrayDims
140254
def variable_names(self):
        
        result = []
        names = javabridge.call(self.jobject, "getVariableNames", "()Ljava/util/Set;")
        for name in javabridge.iterate_collection(names):
            result.append(javabridge.to_string(name))
        return result
527583
def _dimensions(self):
        
        return tuple(d for d in self._all_dimensions if d.dimension_type != DT.MR_CAT)
521192
def _raw_dimensions(self):
        """"""
        return tuple(
            _RawDimension(dimension_dict, self._dimension_dicts)
            for dimension_dict in self._dimension_dicts
        )
926162
def calculate_dimensions(variables):
    
    dims = OrderedDict()
    last_used = {}
    scalar_vars = set(k for k, v in variables.items() if not v.dims)
    for k, var in variables.items():
        for dim, size in zip(var.dims, var.shape):
            if dim in scalar_vars:
                raise ValueError('dimension %r already exists as a scalar '
                                 'variable' % dim)
            if dim not in dims:
                dims[dim] = size
                last_used[dim] = k
            elif dims[dim] != size:
                raise ValueError('conflicting sizes for dimension %r: '
                                 'length %s on %r and length %s on %r' %
                                 (dim, size, k, dims[dim], last_used[dim]))
    return dims
1034746
def variables(self):
    """"""
    result = []
    for _, value in sorted(self.variable_map.items()):
      if isinstance(value, list):
        result.extend(value)
      else:
        result.append(value)
    return result
849074
def get_dimension(data):
    
    result = [0, 0]

    if isinstance(data, list):
        result = get_dimension_array(data)

    elif isinstance(data, dict):
        result = get_dimension_dict(data)

    return result
1020984
def dim_global_size_dict(self):
        
        return { d.name: d.global_size for d in self._dims.itervalues()}
232064
def dimensions
      height = self.count
      width = self.collect{|a| a.length}.max
      [width,height]
    end
577980
def get_dimensions(self):
        """"""
        return FrozenOrderedDict((k, len(v)) for k, v in self.ds.dimensions.items())
890981
def dimensionNames(self):
        
        mainArrayDims = ['Dim{}'.format(dimNr) for dimNr in range(self._array.ndim)]
        nSubDims = len(self._subArrayShape)
        subArrayDims = ['SubDim{}'.format(dimNr) for dimNr in range(nSubDims)]
        return mainArrayDims + subArrayDims
528886
def _iter_dimensions(self):
        """"""
        return (
            Dimension(raw_dimension.dimension_dict, raw_dimension.dimension_type)
            for raw_dimension in self._raw_dimensions
        )
106003
def get_axis_variables(ds):
    '''
    
    '''
    axis_variables = []
    for ncvar in ds.get_variables_by_attributes(axis=lambda x: x is not None):
        axis_variables.append(ncvar.name)
    return axis_variables
840656
def _valid_dimensions(self, dimensions):
        """"""
        if dimensions is None:
            dimensions = self.kdims
        elif not isinstance(dimensions, list):
            dimensions = [dimensions]

        valid_dimensions = []
        for dim in dimensions:
            if isinstance(dim, Dimension): dim = dim.name
            if dim not in self.kdims:
                raise Exception("Supplied dimensions %s not found." % dim)
            valid_dimensions.append(dim)
        return valid_dimensions