Standard deviation for a column

@param dataFrame  the dataframe to
get the column from
@param columnName the name of the column to get the standard
deviation for
@return the column that represents the standard deviation
509378
public static Column std(DataRowsFacade dataFrame, String columnName) {
        return functions.sqrt(var(dataFrame, columnName));
    }
762101
def check_dataframe(self, dataframe):
        
        required_columns = (
            'a',
            'b',
            'm',
            'n',
            'r',
        )
        for column in required_columns:
            if column not in dataframe:
                raise Exception('Required column not in dataframe: {0}'.format(
                    column
                ))
938476
def get_deviations(self):
        
        bt = False
        if not self.istransformed:
            bt = True
            self._transform()
        mean_vec = self.mean()

        df = self.loc[:,:].copy()
        for col in df.columns:
            df.loc[:,col] -= mean_vec[col]
        if bt:
            self._back_transform()
        return type(self).from_dataframe(pst=self.pst,df=df)
870602
def get_column(self, column_name):
        
        frame = self._call_func()
        return DataFrameWrapper(self.name, frame,
                                copy_col=self.copy_col).get_column(column_name)
40365
public Statistics columnStats(String columnName, ColumnStats columnStats) {
		Map<String, String> map = normalizeColumnStats(columnStats);
		this.columnStats.put(columnName, map);
		return this;
	}
1056318
public static double varianceDoublematrixColumn( double[][] matrix, int column, double mean )

    {

        double variance;

        variance = 0;

        for( int i = 0; i < matrix.length; i++ ) {
            variance += (matrix[i][column] - mean) * (matrix[i][column] - mean);
        }

        return variance / matrix.length;

    }
1278749
@Override
    public double getStdDev() {
        // two-pass algorithm for variance, avoids numeric overflow

        if (values.length <= 1) {
            return 0;
        }

        final double mean = getMean();
        double sum = 0;

        for (long value : values) {
            final double diff = value - mean;
            sum += diff * diff;
        }

        final double variance = sum / (values.length - 1);
        return Math.sqrt(variance);
    }
883861
public boolean hasColumn(String columnName) {
        Integer idx = columnNamesIndex.get(columnName);
        return idx != null;
    }
45361
public static Column var(DataRowsFacade dataFrame, String columnName) {
        return dataFrame.get().groupBy(columnName).agg(functions.variance(columnName)).col(columnName);
    }
206479
public int getColumnIndex(String name) {

        int i = findColumn(name);

        if (i == -1) {
            throw Error.error(ErrorCode.X_42501, name);
        }

        return i;
    }
475501
public static int getInt(Cursor cursor, String columnName) {
        if (cursor == null) {
            return -1;
        }

        return cursor.getInt(cursor.getColumnIndex(columnName));
    }
1318807
private ColumnDef getColumnDefByName(CfDef columnFamily, ByteBuffer columnName)
    {
        for (ColumnDef columnDef : columnFamily.getColumn_metadata())
        {
            byte[] currName = columnDef.getName();

            if (ByteBufferUtil.compare(currName, columnName) == 0)
            {
                return columnDef;
            }
        }

        return null;
    }
566733
final D6ModelClassFieldInfo getFieldInfo(String columnName) {
		final D6ModelClassFieldInfo fieldInfo = mColumnNameFieldInfoMap
				.get(columnName);
		return fieldInfo;
	}
689022
public Vec getColumn(int j)
    {
        if(j < 0 || j >= cols())
            throw new ArithmeticException("Column was not a valid value " + j + " not in [0," + (cols()-1) + "]");
        DenseVector c = new DenseVector(rows());
        for(int i =0; i < rows(); i++)
            c.set(i, get(i, j));
        return c;
    }
505318
public double getDouble(String columnName, double defaultValue) {
        int index = getColumnIndex(columnName);
        if (isValidIndex(index)) {
            return getDouble(index);
        } else {
            return defaultValue;
        }
    }
773784
public static String aggregateColumnName(String columnName, String functionName) {
        return String.format("%s [%s]", functionName, columnName);
    }
465537
public Object getColumnValue(String columnName) {
		for ( int j = 0; j < columnNames.length; j++ ) {
			if ( columnNames[j].equals( columnName ) ) {
				return columnValues[j];
			}
		}
		return null;
	}