@nfdi4plants/arctrl 1.0.0-alpha6

package/fable_modules/FsSpreadsheet.4.1.0/FsAddress.fs

@@ -0,0 +1,177 @@
+namespace FsSpreadsheet
+
+
+/// Module containing functions to work with "A1" style excel cell references.
+module CellReference =
+    
+    /// Transforms excel column string indices (e.g. A, B, Z, AA, CD) to index number (starting with A = 1).
+    let colAdressToIndex (columnAdress : string) =
+        let length = columnAdress.Length
+        let mutable sum = 0u
+        for i=0 to length-1 do
+            let c = columnAdress.[length-1-i] |> System.Char.ToUpper
+            let factor = 26. ** (float i) |> uint
+            sum <- sum + ((uint c - 64u) * factor)
+        sum
+
+    /// Transforms number index to excel column string indices (e.g. A, B, Z, AA, CD) (starting with A = 1).
+    let indexToColAdress i =
+        // Cannot use StringBuilder, as it is not compatible with Fable
+        let rec loop index acc =
+            match index with
+            | 0u -> acc
+            | _ ->
+                let mod26 = (index - 1u) % 26u
+                let nextChar = char (uint 'A' + mod26)
+                loop ((index - 1u) / 26u) (string nextChar + acc)
+        loop i ""
+
+    /// Maps 1 based column and row indices to "A1" style reference.
+    let ofIndices column (row : uint32) = 
+        sprintf "%s%i" (indexToColAdress column) row
+
+    /// Maps a "A1" style excel cell reference to a column * row index tuple (1 Based indices).
+    let toIndices (reference : string) = 
+        let inp = reference.ToUpper()
+        let pattern = "([A-Z]*)(\d*)"
+        let regex = System.Text.RegularExpressions.Regex.Match(inp,pattern)
+        
+        if regex.Success then
+            regex.Groups
+            |> fun a -> colAdressToIndex a.[1].Value, uint32 a.[2].Value
+        else 
+            failwithf "Reference %s does not match Excel A1-style" reference
+
+    /// Maps a "A1" style excel cell reference to a column (1 Based indices).
+    let toColIndex (reference : string) = 
+        reference |> toIndices |> fst
+
+    /// Maps a "A1" style excel cell reference to a row (1 Based indices).
+    let toRowIndex (reference : string) = 
+        reference |> toIndices |> snd
+
+    /// Sets the column index (1 Based indices) of a "A1" style excel cell reference.
+    let setColIndex colI (reference : string) = 
+        reference |> toIndices |> fun (_,r) -> ofIndices colI r
+
+    /// Sets the row index (1 Based indices) of a "A1" style excel cell reference.
+    let setRowIndex rowI (reference : string) = 
+        reference |> toIndices |> fun (c,_) -> ofIndices c rowI
+
+    /// Changes the column portion of a "A1"-style reference by the given amount (positive amount = increase and vice versa).
+    let moveHorizontal amount reference = 
+        reference
+        |> toIndices
+        |> fun (c,r) -> (int64 c) + (int64 amount) |> uint32, r
+        ||> ofIndices
+
+    /// Changes the row portion of a "A1"-style reference by the given amount (positive amount = increase and vice versa).
+    let moveVertical amount reference = 
+        reference
+        |> toIndices
+        |> fun (c,r) -> c, (int64 r) + (int64 amount) |> uint32
+        ||> ofIndices
+
+
+type FsAddress(rowNumber : int, columnNumber : int, fixedRow : bool, fixedColumn : bool) =
+
+    let mutable _fixedRow     = fixedRow
+    let mutable _fixedColumn  = fixedColumn
+    let mutable _rowNumber    = rowNumber
+    let mutable _columnNumber = columnNumber
+
+    let mutable _trimmedAddress = ""
+
+    // ----------------------
+    // ALTERNATE CONSTRUCTORS
+    // ----------------------
+
+    new (rowNumber : int, columnLetter : string, fixedRow : bool, fixedColumn : bool) =
+        FsAddress(rowNumber,CellReference.colAdressToIndex columnLetter |> int,fixedRow,fixedColumn)
+
+    new (rowNumber : int, columnNumber : int) =
+        FsAddress(rowNumber,columnNumber,false,false)
+
+    new (cellAddressString : string) =
+        let colIndex,rowIndex = CellReference.toIndices cellAddressString
+        FsAddress(int rowIndex,int colIndex)
+
+    // ----------
+    // PROPERTIES
+    // ----------
+
+    member self.ColumnNumber
+        with get() = _columnNumber
+        and set(colI) = _columnNumber <- colI
+
+    member self.RowNumber
+        with get() = _rowNumber
+        and set(rowI) = _rowNumber <- rowI
+
+    member self.Address 
+        with get() = CellReference.ofIndices (uint32 _columnNumber) (uint32 _rowNumber)
+        and set(address) = 
+            let column,row = CellReference.toIndices address
+            _rowNumber <- int row
+            _columnNumber <- int column
+
+    member self.FixedRow = false
+    member self.FixedColumn = false
+
+
+    // -------
+    // METHODS
+    // -------
+    //let mutable _address = address
+
+    /// <summary>
+    /// Creates a deep copy of the FsAddress.
+    /// </summary>
+    member this.Copy() =
+        let colNo = this.ColumnNumber
+        let rowNo = this.RowNumber
+        let fixRow = this.FixedRow
+        let fixedCol = this.FixedColumn
+        FsAddress(rowNo, colNo, fixRow, fixedCol)
+
+    /// <summary>
+    /// Returns a deep copy of the given FsAddress.
+    /// </summary>
+    static member copy (address : FsAddress) =
+        address.Copy()
+
+    /// <summary>
+    /// Updates the row- and columnIndex respective to the given indices.
+    /// </summary>
+    member self.UpdateIndices(rowIndex,colIndex) = 
+        _columnNumber <- colIndex
+        _rowNumber <- rowIndex
+
+    /// <summary>
+    /// Updates the row- and columnIndex of a given FsAddress respective to the given indices.
+    /// </summary>
+    static member updateIndices rowIndex colIndex (address : FsAddress) =
+        address.UpdateIndices(rowIndex, colIndex)
+        address
+
+    /// <summary>Returns the row- and the columnIndex of the FsAddress.</summary>
+    /// <returns>A tuple consisting of the rowIndex (fst) and the columnIndex (snd).</returns>
+    member self.ToIndices() = _rowNumber,_columnNumber
+
+    /// <summary>Returns the row- and the columnIndex of a given FsAddress.</summary>
+    /// <returns>A tuple consisting of the rowIndex (fst) and the columnIndex (snd).</returns>
+    static member toIndices (address : FsAddress) =
+        address.ToIndices()
+
+    /// <summary>Compares the FsAddress with a given other one.</summary>
+    /// <returns>Returns true if both FsAddresses are equal.</returns>
+    member self.Compare(address : FsAddress) =
+        self.Address        = address.Address      &&
+        self.ColumnNumber   = address.ColumnNumber &&
+        self.RowNumber      = address.RowNumber    &&
+        self.FixedColumn    = address.FixedColumn  &&
+        self.FixedRow       = address.FixedRow
+
+    /// <summary>Checks if 2 FsAddresses are equal.</summary>
+    static member compare (address1 : FsAddress) (address2 : FsAddress) =
+        address1.Compare address2

package/fable_modules/FsSpreadsheet.4.1.0/FsAddress.fs.js

@@ -0,0 +1,249 @@
+import { toFail, printf, toText } from "../fable-library.4.1.4/String.js";
+import { create, match } from "../fable-library.4.1.4/RegExp.js";
+import { parse } from "../fable-library.4.1.4/Int32.js";
+import { toUInt32, fromInt32, fromUInt32, op_Addition, toInt64 } from "../fable-library.4.1.4/BigInt.js";
+import { class_type } from "../fable-library.4.1.4/Reflection.js";
+
+/**
+ * Transforms excel column string indices (e.g. A, B, Z, AA, CD) to index number (starting with A = 1).
+ */
+export function CellReference_colAdressToIndex(columnAdress) {
+    const length = columnAdress.length | 0;
+    let sum = 0;
+    for (let i = 0; i <= (length - 1); i++) {
+        let c;
+        const arg = columnAdress[(length - 1) - i];
+        c = arg.toLocaleUpperCase();
+        let factor;
+        const value = Math.pow(26, i);
+        factor = (value >>> 0);
+        sum = (sum + ((c.charCodeAt(0) - 64) * factor));
+    }
+    return sum;
+}
+
+/**
+ * Transforms number index to excel column string indices (e.g. A, B, Z, AA, CD) (starting with A = 1).
+ */
+export function CellReference_indexToColAdress(i) {
+    const loop = (index_mut, acc_mut) => {
+        loop:
+        while (true) {
+            const index = index_mut, acc = acc_mut;
+            if (index === 0) {
+                return acc;
+            }
+            else {
+                const mod26 = (index - 1) % 26;
+                index_mut = ~~((index - 1) / 26);
+                acc_mut = (String.fromCharCode(65 + mod26) + acc);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(i, "");
+}
+
+/**
+ * Maps 1 based column and row indices to "A1" style reference.
+ */
+export function CellReference_ofIndices(column, row) {
+    const arg = CellReference_indexToColAdress(column);
+    return toText(printf("%s%i"))(arg)(row);
+}
+
+/**
+ * Maps a "A1" style excel cell reference to a column * row index tuple (1 Based indices).
+ */
+export function CellReference_toIndices(reference) {
+    const inp = reference.toLocaleUpperCase();
+    const regex = match(create("([A-Z]*)(\\d*)"), inp);
+    if (regex != null) {
+        const a = regex;
+        return [CellReference_colAdressToIndex(a[1] || ""), parse(a[2] || "", 511, true, 32)];
+    }
+    else {
+        return toFail(printf("Reference %s does not match Excel A1-style"))(reference);
+    }
+}
+
+/**
+ * Maps a "A1" style excel cell reference to a column (1 Based indices).
+ */
+export function CellReference_toColIndex(reference) {
+    return CellReference_toIndices(reference)[0];
+}
+
+/**
+ * Maps a "A1" style excel cell reference to a row (1 Based indices).
+ */
+export function CellReference_toRowIndex(reference) {
+    return CellReference_toIndices(reference)[1];
+}
+
+/**
+ * Sets the column index (1 Based indices) of a "A1" style excel cell reference.
+ */
+export function CellReference_setColIndex(colI, reference) {
+    return CellReference_ofIndices(colI, CellReference_toIndices(reference)[1]);
+}
+
+/**
+ * Sets the row index (1 Based indices) of a "A1" style excel cell reference.
+ */
+export function CellReference_setRowIndex(rowI, reference) {
+    return CellReference_ofIndices(CellReference_toIndices(reference)[0], rowI);
+}
+
+/**
+ * Changes the column portion of a "A1"-style reference by the given amount (positive amount = increase and vice versa).
+ */
+export function CellReference_moveHorizontal(amount, reference) {
+    let value;
+    let tupledArg_1;
+    const tupledArg = CellReference_toIndices(reference);
+    tupledArg_1 = [(value = toInt64(op_Addition(toInt64(fromUInt32(tupledArg[0])), toInt64(fromInt32(amount)))), toUInt32(value) >>> 0), tupledArg[1]];
+    return CellReference_ofIndices(tupledArg_1[0], tupledArg_1[1]);
+}
+
+/**
+ * Changes the row portion of a "A1"-style reference by the given amount (positive amount = increase and vice versa).
+ */
+export function CellReference_moveVertical(amount, reference) {
+    let value;
+    let tupledArg_1;
+    const tupledArg = CellReference_toIndices(reference);
+    tupledArg_1 = [tupledArg[0], (value = toInt64(op_Addition(toInt64(fromUInt32(tupledArg[1])), toInt64(fromInt32(amount)))), toUInt32(value) >>> 0)];
+    return CellReference_ofIndices(tupledArg_1[0], tupledArg_1[1]);
+}
+
+export class FsAddress {
+    constructor(rowNumber, columnNumber, fixedRow, fixedColumn) {
+        this._fixedRow = fixedRow;
+        this._fixedColumn = fixedColumn;
+        this._rowNumber = (rowNumber | 0);
+        this._columnNumber = (columnNumber | 0);
+        this._trimmedAddress = "";
+    }
+}
+
+export function FsAddress_$reflection() {
+    return class_type("FsSpreadsheet.FsAddress", void 0, FsAddress);
+}
+
+export function FsAddress_$ctor_Z4C746FC0(rowNumber, columnNumber, fixedRow, fixedColumn) {
+    return new FsAddress(rowNumber, columnNumber, fixedRow, fixedColumn);
+}
+
+export function FsAddress_$ctor_Z668C30D9(rowNumber, columnLetter, fixedRow, fixedColumn) {
+    return FsAddress_$ctor_Z4C746FC0(rowNumber, ~~CellReference_colAdressToIndex(columnLetter), fixedRow, fixedColumn);
+}
+
+export function FsAddress_$ctor_Z37302880(rowNumber, columnNumber) {
+    return FsAddress_$ctor_Z4C746FC0(rowNumber, columnNumber, false, false);
+}
+
+export function FsAddress_$ctor_Z721C83C5(cellAddressString) {
+    const patternInput = CellReference_toIndices(cellAddressString);
+    return FsAddress_$ctor_Z37302880(~~patternInput[1], ~~patternInput[0]);
+}
+
+export function FsAddress__get_ColumnNumber(self) {
+    return self._columnNumber;
+}
+
+export function FsAddress__set_ColumnNumber_Z524259A4(self, colI) {
+    self._columnNumber = (colI | 0);
+}
+
+export function FsAddress__get_RowNumber(self) {
+    return self._rowNumber;
+}
+
+export function FsAddress__set_RowNumber_Z524259A4(self, rowI) {
+    self._rowNumber = (rowI | 0);
+}
+
+export function FsAddress__get_Address(self) {
+    return CellReference_ofIndices(self._columnNumber >>> 0, self._rowNumber >>> 0);
+}
+
+export function FsAddress__set_Address_Z721C83C5(self, address) {
+    const patternInput = CellReference_toIndices(address);
+    self._rowNumber = (~~patternInput[1] | 0);
+    self._columnNumber = (~~patternInput[0] | 0);
+}
+
+export function FsAddress__get_FixedRow(self) {
+    return false;
+}
+
+export function FsAddress__get_FixedColumn(self) {
+    return false;
+}
+
+/**
+ * Creates a deep copy of the FsAddress.
+ */
+export function FsAddress__Copy(this$) {
+    const colNo = FsAddress__get_ColumnNumber(this$) | 0;
+    return FsAddress_$ctor_Z4C746FC0(FsAddress__get_RowNumber(this$), colNo, FsAddress__get_FixedRow(this$), FsAddress__get_FixedColumn(this$));
+}
+
+/**
+ * Returns a deep copy of the given FsAddress.
+ */
+export function FsAddress_copy_6D30B323(address) {
+    return FsAddress__Copy(address);
+}
+
+/**
+ * Updates the row- and columnIndex respective to the given indices.
+ */
+export function FsAddress__UpdateIndices_Z37302880(self, rowIndex, colIndex) {
+    self._columnNumber = (colIndex | 0);
+    self._rowNumber = (rowIndex | 0);
+}
+
+/**
+ * Updates the row- and columnIndex of a given FsAddress respective to the given indices.
+ */
+export function FsAddress_updateIndices(rowIndex, colIndex, address) {
+    FsAddress__UpdateIndices_Z37302880(address, rowIndex, colIndex);
+    return address;
+}
+
+/**
+ * Returns the row- and the columnIndex of the FsAddress.
+ */
+export function FsAddress__ToIndices(self) {
+    return [self._rowNumber, self._columnNumber];
+}
+
+/**
+ * Returns the row- and the columnIndex of a given FsAddress.
+ */
+export function FsAddress_toIndices_6D30B323(address) {
+    return FsAddress__ToIndices(address);
+}
+
+/**
+ * Compares the FsAddress with a given other one.
+ */
+export function FsAddress__Compare_6D30B323(self, address) {
+    if ((((FsAddress__get_Address(self) === FsAddress__get_Address(address)) && (FsAddress__get_ColumnNumber(self) === FsAddress__get_ColumnNumber(address))) && (FsAddress__get_RowNumber(self) === FsAddress__get_RowNumber(address))) && (FsAddress__get_FixedColumn(self) === FsAddress__get_FixedColumn(address))) {
+        return FsAddress__get_FixedRow(self) === FsAddress__get_FixedRow(address);
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Checks if 2 FsAddresses are equal.
+ */
+export function FsAddress_compare(address1, address2) {
+    return FsAddress__Compare_6D30B323(address1, address2);
+}
+

package/fable_modules/FsSpreadsheet.4.1.0/FsColumn.fs

@@ -0,0 +1,200 @@
+namespace FsSpreadsheet
+
+open System.Collections.Generic
+open System.Collections
+
+open Fable.Core
+// Type based on the type XLRow used in ClosedXml
+/// <summary>
+/// Creates an FsColumn from the given FsRangeAddress, consisting of FsCells within a given FsCellsCollection, and a styleValue.
+/// </summary>
+/// <remarks>The FsCellsCollection must only cover 1 column!</remarks>
+/// <exception cref="System.Exception">if given FsCellsCollection has more than 1 column.</exception>
+[<AttachMembers>]
+type FsColumn (rangeAddress : FsRangeAddress, cells : FsCellsCollection)= 
+
+    inherit FsRangeBase(rangeAddress)
+
+    let cells = cells
+
+    // ----------
+    // Creation
+    // ----------
+
+    /// Creates an empty FsColumn, ranging from row 0, column 0 to row 0, column (1-based).
+    static member empty() = FsColumn (FsRangeAddress(FsAddress(0,0), FsAddress(0,0)), FsCellsCollection())
+
+    /// <summary>
+    /// Create an FsColumn from a given FsCellsCollection and an columnColumn.
+    /// </summary>
+    /// <remarks>The appropriate range of the cells (i.e. minimum colIndex and maximum colIndex) is derived from the FsCells with the matching rowIndex.</remarks>
+    static member createAt(index : int32, (cells : FsCellsCollection)) = 
+        let getIndexBy (f : (FsCell -> int) -> seq<FsCell> -> FsCell) = 
+            match cells.GetCellsInColumn index |> Seq.length with
+            | 0 -> 1
+            | _ ->
+                (
+                    cells.GetCellsInColumn index 
+                    |> f (fun c -> c.Address.RowNumber)
+                ).Address.RowNumber
+        let minRowIndex = getIndexBy Seq.minBy
+        let maxRowIndex = getIndexBy Seq.maxBy
+        FsColumn (FsRangeAddress(FsAddress(minRowIndex, index), FsAddress(maxRowIndex, index)), cells)
+
+    interface IEnumerable<FsCell> with
+        member this.GetEnumerator() : System.Collections.Generic.IEnumerator<FsCell> = this.Cells.GetEnumerator()
+
+    interface IEnumerable with
+        member this.GetEnumerator() = (this :> IEnumerable<FsCell>).GetEnumerator() :> IEnumerator
+
+    // ----------
+    // PROPERTIES
+    // ----------
+
+    /// The associated FsCells.
+    member this.Cells = 
+        base.Cells(cells)
+
+    /// <summary>
+    /// The index of the FsColumn.
+    /// </summary>
+    member this.Index 
+        with get() = this.RangeAddress.FirstAddress.ColumnNumber
+        and set(i) = 
+            this.RangeAddress.FirstAddress.ColumnNumber <- i
+            this.RangeAddress.LastAddress.ColumnNumber <- i
+
+    /// <summary>
+    /// The number of the lowest row index of the FsColumn where an FsCell exists.
+    /// </summary>
+    member this.MinRowIndex
+        with get() = this.RangeAddress.FirstAddress.RowNumber
+
+    /// <summary>
+    /// The number of the highest row index of the FsColumn where an FsCell exists.
+    /// </summary>
+    member this.MaxRowIndex
+        with get() = this.RangeAddress.LastAddress.RowNumber
+
+
+    // -------
+    // METHODS
+    // -------
+
+    /// <summary>
+    /// Creates a deep copy of this FsColumn.
+    /// </summary>
+    member this.Copy() =
+        let ra = this.RangeAddress.Copy()
+        let cells = this.Cells |> Seq.map (fun c -> c.Copy())
+        let fcc = FsCellsCollection()
+        fcc.Add cells
+        FsColumn(ra, fcc)
+
+    /// <summary>
+    /// Returns a deep copy of a given FsColumn.
+    /// </summary>
+    static member copy (column : FsColumn) =
+        column.Copy()
+
+    /// <summary>
+    /// Returns the index of the given FsColumn.
+    /// </summary>
+    static member getIndex (column : FsColumn) = 
+        column.Index
+
+    /// <summary>
+    /// Checks if there is an FsCell at given row index.
+    /// </summary>
+    /// <param name="rowIndex">The number of the row where the presence of an FsCell shall be checked.</param>
+    member this.HasCellAt(rowIndex) =
+        this.Cells
+        |> Seq.exists (fun c -> c.RowNumber = rowIndex)
+
+    /// <summary>
+    /// Checks if there is an FsCell at given row index of a given FsColumn.
+    /// </summary>
+    /// <param name="colIndex">The number of the row where the presence of an FsCell shall be checked.</param>
+    static member hasCellAt rowIndex (column : FsColumn) =
+        column.HasCellAt rowIndex
+
+    /// <summary>
+    /// Returns the FsCell at rowIndex.
+    /// </summary>
+    member this.Item (rowIndex) =
+        // use FsRangeBase call with colindex 1
+        base.Cell(FsAddress(rowIndex, 1), cells)
+
+    /// <summary>
+    /// Returns the FsCell at the given rowIndex from an FsColumn.
+    /// </summary>
+    static member item rowIndex (column : FsColumn) =
+        column.Item(rowIndex)
+
+    /// <summary>
+    /// Returns the FsCell at the given rowIndex if it exists. Else returns None.
+    /// </summary>
+    /// <param name="rowIndex">The number of the column where the FsCell shall be retrieved.</param>
+    member this.TryItem(rowIndex) =
+        if this.HasCellAt rowIndex then Some this[rowIndex]
+        else None
+
+    /// <summary>
+    /// Returns the FsCell at the given rowIndex if it exists in the given FsColumn. Else returns None.
+    /// </summary>
+    /// <param name="rowIndex">The number of the column where the FsCell shall be retrieved.</param>
+    static member tryItem rowIndex (column : FsColumn) =
+        column.TryItem rowIndex
+
+    ///// <summary>
+    ///// Inserts the value at columnIndex as an FsCell. If there is an FsCell at the position, this FsCells and all the ones /right /to it are shifted to the right.
+    ///// </summary>
+    //member this.InsertValueAt(colIndex, (value : 'a)) =
+    //    let cell = FsCell(value)
+    //    cells.Add(int32 this.Index, int32 colIndex, cell)
+
+    ///// <summary>
+    ///// Adds a value at the given row- and columnIndex to FsRow using.
+    /////
+    ///// If a cell exists in the given position, shoves it to the right.
+    ///// </summary>
+    //static member insertValueAt colIndex value (row : FsRow) =
+    //    row.InsertValueAt(colIndex, value) |> ignore
+    //    row
+
+    //member this.SortCells() = _cells <- _cells |> List.sortBy (fun c -> c.WorksheetColumn)
+
+    // TO DO (later)
+    ///// Takes an FsCellsCollection and creates an FsRow from the given rowIndex and the cells in the FsCellsCollection that share the same rowIndex.
+    //static member fromCellsCollection rowIndex (cellsCollection : FsCellsCollection) =
+
+    /// <summary>
+    /// Transforms the FsColumn into a dense FsColumn.
+    /// 
+    /// FsColumns are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsColumns, such "empty positions" are then filled with empty FsCells.
+    /// </summary>
+    member this.ToDenseColumn() =
+        for i = this.MinRowIndex to this.MaxRowIndex do 
+            ignore this[i]
+
+    /// <summary>
+    /// Transforms the given FsColumn into a dense FsColumn.
+    /// 
+    /// FsColumns are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsColumns, such "empty positions" are then filled with empty FsCells.
+    /// </summary>
+    /// <param name="column">The FsColumn that gets transformed into a dense FsColumn.</param>
+    /// <remarks>This is an in-place operation.</remarks>
+    static member toDenseColumn (column : FsColumn) =
+        column.ToDenseColumn()
+        column
+
+    /// <summary>
+    /// Takes a given FsColumn and returns a new dense FsColumn from it.
+    /// 
+    /// FsColumns are sparse by default. This means there are no FsCells present between positions with that are filled with FsCells. In dense FsColumns, such "empty positions" are then filled with empty FsCells.
+    /// </summary>
+    /// <param name="column">The FsColumn that whose copy gets transformed into a dense FsColumn.</param>
+    static member createDenseColumnOf (column : FsColumn) =
+        let newColumn = column.Copy()
+        newColumn.ToDenseColumn()
+        newColumn