Create a new float column on the table.

        :param column: The column
        :type column: str

        :type total: int

        :type places: 2

        :rtype: Fluent
765117
def float(self, column, total=8, places=2):
        
        return self._add_column("float", column, total=total, places=places)
1341076
def transform(self, column):
        
        self.check_data_type()

        return pd.DataFrame({self.col_name: np.exp(column[self.col_name])})
550669
function (column, col) {
		var rawColumns = this.rawColumns,
			columns = this.columns, 
			row = column.length,
			val,
			floatVal,
			trimVal,
			trimInsideVal,
			firstRowAsNames = this.firstRowAsNames,
			isXColumn = inArray(col, this.valueCount.xColumns) !== -1,
			dateVal,
			backup = [],
			diff,
			chartOptions = this.chartOptions,
			descending,
			columnTypes = this.options.columnTypes || [],
			columnType = columnTypes[col],
			forceCategory = isXColumn && ((chartOptions && chartOptions.xAxis && splat(chartOptions.xAxis)[0].type === 'category') || columnType === 'string');
		
		if (!rawColumns[col]) {
			rawColumns[col] = [];
		}
		while (row--) {
			val = backup[row] || column[row];
			
			trimVal = this.trim(val);
			trimInsideVal = this.trim(val, true);
			floatVal = parseFloat(trimInsideVal);

			// Set it the first time
			if (rawColumns[col][row] === undefined) {
				rawColumns[col][row] = trimVal;
			}
			
			// Disable number or date parsing by setting the X axis type to category
			if (forceCategory || (row === 0 && firstRowAsNames)) {
				column[row] = trimVal;

			} else if (+trimInsideVal === floatVal) { // is numeric
			
				column[row] = floatVal;
				
				// If the number is greater than milliseconds in a year, assume datetime
				if (floatVal > 365 * 24 * 3600 * 1000 && columnType !== 'float') {
					column.isDatetime = true;
				} else {
					column.isNumeric = true;
				}

				if (column[row + 1] !== undefined) {
					descending = floatVal > column[row + 1];
				}
			
			// String, continue to determine if it is a date string or really a string
			} else {
				dateVal = this.parseDate(val);
				// Only allow parsing of dates if this column is an x-column
				if (isXColumn && typeof dateVal === 'number' && !isNaN(dateVal) && columnType !== 'float') { // is date
					backup[row] = val; 
					column[row] = dateVal;
					column.isDatetime = true;

					// Check if the dates are uniformly descending or ascending. If they 
					// are not, chances are that they are a different time format, so check
					// for alternative.
					if (column[row + 1] !== undefined) {
						diff = dateVal > column[row + 1];
						if (diff !== descending && descending !== undefined) {
							if (this.alternativeFormat) {
								this.dateFormat = this.alternativeFormat;
								row = column.length;
								this.alternativeFormat = this.dateFormats[this.dateFormat].alternative;
							} else {
								column.unsorted = true;
							}
						}
						descending = diff;
					}
				
				} else { // string
					column[row] = trimVal === '' ? null : trimVal;
					if (row !== 0 && (column.isDatetime || column.isNumeric)) {
						column.mixed = true;
					}
				}
			}
		}

		// If strings are intermixed with numbers or dates in a parsed column, it is an indication
		// that parsing went wrong or the data was not intended to display as numbers or dates and 
		// parsing is too aggressive. Fall back to categories. Demonstrated in the 
		// highcharts/demo/column-drilldown sample.
		if (isXColumn && column.mixed) {
			columns[col] = rawColumns[col];
		}

		// If the 0 column is date or number and descending, reverse all columns. 
		if (isXColumn && descending && this.options.sort) {
			for (col = 0; col < columns.length; col++) {
				columns[col].reverse();
				if (firstRowAsNames) {
					columns[col].unshift(columns[col].pop());
				}
			}
		}
	}
1340263
def add_column(self, name, type_name, options=None):
        
        column = Column(name, type_name, options)

        self._add_column(column)

        return column
713876
def insert_empty_columns(self, x: int, amount: int = 1) -> None:
        """"""
        def transform_columns(
                column: Union[int, float],
                row: Union[int, float]
        ) -> Tuple[Union[int, float], Union[int, float]]:
            return column + (amount if column >= x else 0), row
        self._transform_coordinates(transform_columns)
60052
def _create_column(values, dtype):
    ""
    if str(dtype) == "tensor(int64)":
        return numpy.array(values, dtype=numpy.int64)
    elif str(dtype) == "tensor(float)":
        return numpy.array(values, dtype=numpy.float32)
    else:
        raise OnnxRuntimeAssertionError("Unable to create one column from dtype '{0}'".format(dtype))
910740
def _add(self, column):
        
        columns_for_table = self.data.setdefault(column.es_index, {})
        existing_columns = columns_for_table.setdefault(column.name, [])

        for canonical in existing_columns:
            if canonical is column:
                return None
            if canonical.es_type == column.es_type:
                if column.last_updated > canonical.last_updated:
                    for key in Column.__slots__:
                        old_value = canonical[key]
                        new_value = column[key]
                        if new_value == None:
                            pass  # DO NOT BOTHER CLEARING OLD VALUES (LIKE cardinality AND paritiions)
                        elif new_value == old_value:
                            pass  # NO NEED TO UPDATE WHEN NO CHANGE MADE (COMMON CASE)
                        else:
                            canonical[key] = new_value
                return canonical
        existing_columns.append(column)
        return column
361798
def sum_(self, col: str) -> float:
        
        try:
            df = self.df[col]
            num = float(df.sum())
            return num
        except Exception as e:
            self.err(e, "Can not sum data on column " + str(col))
604841
public void addColumn(String column) {

        m_columns.add(new CmsSimpleQueryFragment(column, Collections.<Object> emptyList()));
    }
1198696
def pluck(self, column):
        
        result = self.first([column])

        if result:
            return result[column]
1220901
def add_column(self, column):
        """"""
        self.columns.append(column.name)
        self.column_funcs.append(column.path)

        if column.mask is not None:
            self.mask_parts.add(column.mask)
857781
public void addColumn(final WTableColumn column) {
		columns.add(column);
		WDataTableRowRenderer renderer = (WDataTableRowRenderer) repeater.getRepeatedComponent();
		renderer.addColumn(column, columns.getChildCount() - 1);
	}
427912
public function addColumn($column) {
        $columns = $this->getColumns();
        $columns[] = $column;
        $this->setColumns($columns);
    }
479108
def _add_column(self, column):
        
        self._columns.append(column)
        if self._blist:
            self._data.append(blist([None] * len(self._index)))
        else:
            self._data.append([None] * len(self._index))
623852
def _make_op(self, column, op, value):
        
        if not op:
            return None
        if op == '>':
            return column>value
        elif op == '<':
            return column<value
        elif op == '>=':
            return column>=value
        elif op == '<=':
            return column<=value
        elif op == '==':
            return column==value
        elif op == '!=':
            return column!=value
        elif op == 'in':
            return column.in_(value)
        else:
            raise KeyError('Not support this op[%s] value' % op)
1217251
def column(self, col):
        
        if type(col) is str:
            for c in self._cols:
                if c.name == col:
                    return c
        else:
            return self._cols[col]
362649
public void addColumn(FastTrackColumn column)
   {
      FastTrackField type = column.getType();
      Object[] data = column.getData();
      for (int index = 0; index < data.length; index++)
      {
         MapRow row = getRow(index);
         row.getMap().put(type, data[index]);
      }
   }