feidlambda v0.4 updates

_feidlambda/feid_APPLY.sc

@@ -0,0 +1,29 @@
+// NONE --> APPLY_COLUMN
+APPLY_COLUMN = LAMBDA(array, index_vector, LAMBDA_FUNCTION,
+    LET(
+        index_vector, SORT(index_vector),
+        selected_array, CHOOSECOLS(array, index_vector),
+        applied_array, LAMBDA_FUNCTION(selected_array),
+        sequence_vector, SEQUENCE(COLUMNS(array)),
+        logical_vector, BYROW(
+            sequence_vector,
+            LAMBDA(row, OR(row = index_vector))
+        ),
+        scan_vector, SCAN(
+            0,
+            logical_vector,
+            LAMBDA(acc, curr, IF(curr, acc + 1, acc))
+        ),
+        position_vector, scan_vector + COLUMNS(array),
+        all_array, HSTACK(array, applied_array),
+        selected_vector, MAP(
+            logical_vector,
+            sequence_vector,
+            position_vector,
+            LAMBDA(logical_el, seq_el, pos_el,
+                IF(logical_el, pos_el, seq_el)
+            )
+        ),
+        CHOOSECOLS(all_array, selected_vector)
+    )
+);

_feidlambda/feid_FILTER → _feidlambda/feid_FILTER.sc

@@ -5,7 +5,10 @@ FILTER_DROP_ROWS = LAMBDA(array, row_index,
         row_index_clean, FILTER(row_index, NOT(ISBLANK(row_index))),
         nrows, ROWS(array),
         row_sequence, SEQUENCE(nrows),
-        selected_row, BYROW(row_sequence, LAMBDA(each_row, OR(each_row = row_index_clean))),
+        selected_row, BYROW(
+            row_sequence,
+            LAMBDA(each_row, OR(each_row = row_index_clean))
+        ),
         FILTER(array, NOT(selected_row))
     )
 );
@@ -14,10 +17,16 @@ FILTER_DROP_ROWS = LAMBDA(array, row_index,
 FILTER_DROP_COLUMNS = LAMBDA(array, column_index,
     LET(
         column_index, TOROW(column_index),
-        column_index_clean, FILTER(column_index, NOT(ISBLANK(column_index))),
+        column_index_clean, FILTER(
+            column_index,
+            NOT(ISBLANK(column_index))
+        ),
         ncols, COLUMNS(array),
         col_sequence, SEQUENCE(1, ncols),
-        selected_col, BYCOL(col_sequence, LAMBDA(each_col, OR(each_col = column_index_clean))),
+        selected_col, BYCOL(
+            col_sequence,
+            LAMBDA(each_col, OR(each_col = column_index_clean))
+        ),
         FILTER(array, NOT(selected_col))
     )
 );
@@ -32,24 +41,45 @@ FILTER_FUNC_COLUMN = LAMBDA(
     [label_function],
     [take_first_only],
     LET(
-        take_first_only, IF(ISOMITTED(take_first_only), FALSE, take_first_only),
+        take_first_only, IF(
+            ISOMITTED(take_first_only),
+            FALSE,
+            take_first_only
+        ),
         column_index, IF(ISOMITTED(column_index), 1, column_index),
         label_col, IF(ISOMITTED(label_col), column_index, label_col),
         with_label, IF(ISOMITTED(with_label), FALSE, with_label),
         function, IF(ISOMITTED(function), LAMBDA(x, MAX(x)), function),
-        label_function, IF(ISOMITTED(label_function), "func", label_function),
+        label_function, IF(
+            ISOMITTED(label_function),
+            "func",
+            label_function
+        ),
         selected_vector, CHOOSECOLS(array, column_index),
         func_value, function(selected_vector),
         selected_logical, selected_vector = func_value,
         array_filter, FILTER(array, selected_logical),
-        array_func, IF(take_first_only, TAKE(array_filter, 1), array_filter),
-        label, MAKEARRAY(ROWS(array_func), 1, LAMBDA(x, y, CONCAT(label_col, "_", label_function))),
+        array_func, IF(
+            take_first_only,
+            TAKE(array_filter, 1),
+            array_filter
+        ),
+        label, MAKEARRAY(
+            ROWS(array_func),
+            1,
+            LAMBDA(x, y, CONCAT(label_col, "_", label_function))
+        ),
         IF(with_label, HSTACK(label, array_func), array_func)
     )
 );
 
 // FILTER_FUNC_COLUMN --> FILTER_MINMAX_COLUMN
-FILTER_MINMAX_COLUMN = LAMBDA(array, [column_index], [with_label], [label_col], [take_first_only],
+FILTER_MINMAX_COLUMN = LAMBDA(
+    array,
+    [column_index],
+    [with_label],
+    [label_col],
+    [take_first_only],
     LET(
         func_1, LAMBDA(x, MIN(x)),
         label_func_1, "min",
@@ -87,16 +117,40 @@ _RECURSIVE_FILTER_MINMAX = LAMBDA(
     [label_vector],
     [take_first_only],
     LET(
-        ignore_first_column, IF(ISOMITTED(ignore_first_column), FALSE, ignore_first_column),
+        ignore_first_column, IF(
+            ISOMITTED(ignore_first_column),
+            FALSE,
+            ignore_first_column
+        ),
         stop_col, IF(ignore_first_column, 2, 1),
-        label_vector, IF(ISOMITTED(label_vector), SEQUENCE(1, COLUMNS(array)), label_vector),
-        new_label, IF(stop_col = 2, HSTACK({" "}, label_vector), label_vector),
+        label_vector, IF(
+            ISOMITTED(label_vector),
+            SEQUENCE(1, COLUMNS(array)),
+            label_vector
+        ),
+        new_label, IF(
+            stop_col = 2,
+            HSTACK({" "}, label_vector),
+            label_vector
+        ),
         label_col, CHOOSECOLS(new_label, ntry),
         IF(
             ntry = stop_col,
-            FILTER_MINMAX_COLUMN(array, ntry, with_label, label_col, take_first_only),
+            FILTER_MINMAX_COLUMN(
+                array,
+                ntry,
+                with_label,
+                label_col,
+                take_first_only
+            ),
             LET(
-                results, FILTER_MINMAX_COLUMN(array, ntry, with_label, label_col, take_first_only),
+                results, FILTER_MINMAX_COLUMN(
+                    array,
+                    ntry,
+                    with_label,
+                    label_col,
+                    take_first_only
+                ),
                 next_try, ntry - 1,
                 VSTACK(
                     _RECURSIVE_FILTER_MINMAX(
@@ -115,7 +169,12 @@ _RECURSIVE_FILTER_MINMAX = LAMBDA(
 );
 
 // _RECURSIVE_FILTER_MINMAX --> FILTER_MINMAX_ARRAY
-FILTER_MINMAX_ARRAY = LAMBDA(array, [ignore_first_column], [with_label], [label_vector], [take_first_only],
+FILTER_MINMAX_ARRAY = LAMBDA(
+    array,
+    [ignore_first_column],
+    [with_label],
+    [label_vector],
+    [take_first_only],
     _RECURSIVE_FILTER_MINMAX(
         array,
         COLUMNS(array),

_feidlambda/feid_GET.sc

@@ -0,0 +1,89 @@
+// NONE --> GET_INDEX_2D
+GET_INDEX_2D = LAMBDA(lookup_value, array, [return_as_order],
+    LET(
+        return_as_order, IF(
+            ISOMITTED(return_as_order),
+            FALSE,
+            return_as_order
+        ),
+        nrows, ROWS(array),
+        ncols, COLUMNS(array),
+        size, nrows * ncols,
+        array_flatten, TOCOL(array, , TRUE),
+        index_sequence, SEQUENCE(nrows, ncols, 1, 1),
+        rows_sequence, MAKEARRAY(nrows, ncols, LAMBDA(x, y, x)),
+        columns_sequence, MAKEARRAY(nrows, ncols, LAMBDA(x, y, y)),
+        rows_flatten, TOCOL(rows_sequence, , TRUE),
+        columns_flatten, TOCOL(columns_sequence, , TRUE),
+        index_flatten, TOCOL(index_sequence, , TRUE),
+        lookup_table, HSTACK(index_flatten, rows_flatten, columns_flatten),
+        lookup_result, FILTER(lookup_table, array_flatten = lookup_value),
+        IF(return_as_order, CHOOSECOLS(lookup_result, 1), lookup_result)
+    )
+);
+
+// _RECURSIVE_LOOKUP --> _RECURSIVE_LOOKUP
+_RECURSIVE_LOOKUP = LAMBDA(
+    ntry,
+    lookup_value,
+    lookup_vector,
+    return_array,
+    [if_not_found],
+    [match_mode],
+    [search_mode],
+    LET(
+        lookup_value, TOCOL(lookup_value),
+        LET(
+            selected_value, VALUE(
+                ARRAYTOTEXT(CHOOSEROWS(lookup_value, ntry))
+            ),
+            result, XLOOKUP(
+                selected_value,
+                lookup_vector,
+                return_array,
+                if_not_found,
+                match_mode,
+                search_mode
+            ),
+            IF(
+                ntry = 1,
+                result,
+                VSTACK(
+                    _RECURSIVE_LOOKUP(
+                        ntry - 1,
+                        lookup_value,
+                        lookup_vector,
+                        return_array,
+                        if_not_found,
+                        match_mode,
+                        search_mode
+                    ),
+                    result
+                )
+            )
+        )
+    )
+);
+
+// GET_RECURSIVE_LOOKUP --> GET_XLOOKUP
+GET_XLOOKUP = LAMBDA(
+    lookup_value,
+    lookup_vector,
+    return_array,
+    [if_not_found],
+    [match_mode],
+    [search_mode],
+    LET(
+        lookup_value, TOCOL(lookup_value),
+        ntry, ROWS(lookup_value),
+        _RECURSIVE_LOOKUP(
+            ntry,
+            lookup_value,
+            lookup_vector,
+            return_array,
+            if_not_found,
+            match_mode,
+            search_mode
+        )
+    )
+);

_feidlambda/feid_IS → _feidlambda/feid_IS.sc

@@ -2,7 +2,12 @@
 IS_ALL_IN_VECTOR = LAMBDA(lookup_vector, array,
     LET(
         lookup_vector, TOCOL(lookup_vector),
-        MAP(array, LAMBDA(element, OR(BYROW(lookup_vector, LAMBDA(lookup, element = lookup)))))
+        MAP(
+            array,
+            LAMBDA(element,
+                OR(BYROW(lookup_vector, LAMBDA(lookup, element = lookup)))
+            )
+        )
     )
 );
 
@@ -16,7 +21,10 @@ IS_COLS_EQUAL_VECTOR = LAMBDA(lookup_vector, array,
         IF(
             ncols_array = ncols_vector,
             LET(
-                repeat_array, CHOOSEROWS(lookup_vector, SEQUENCE(nrows_array, , 1, 0)),
+                repeat_array, CHOOSEROWS(
+                    lookup_vector,
+                    SEQUENCE(nrows_array, , 1, 0)
+                ),
                 MAP(array, repeat_array, LAMBDA(x, y, x = y))
             ),
             "N/A"
@@ -27,7 +35,11 @@ IS_COLS_EQUAL_VECTOR = LAMBDA(lookup_vector, array,
 // IS_COLS_EQUAL_LOOKUP_VECTOR --> IS_ALL_COLS_EQUAL_LOOKUP_VECTOR
 IS_ALL_COLS_EQUAL_VECTOR = LAMBDA(lookup_vector, array, [logical_function],
     LET(
-        logical_function, IF(ISOMITTED(logical_function), LAMBDA(x, OR(x)), logical_function),
+        logical_function, IF(
+            ISOMITTED(logical_function),
+            LAMBDA(x, OR(x)),
+            logical_function
+        ),
         array_boolean, IS_COLS_EQUAL_VECTOR(lookup_vector, array),
         BYROW(array_boolean, LAMBDA(each_row, logical_function(each_row)))
     )
@@ -36,15 +48,23 @@ IS_ALL_COLS_EQUAL_VECTOR = LAMBDA(lookup_vector, array, [logical_function],
 // NONE --> IS_ROWS_LOGICAL
 IS_ROWS_LOGICAL = LAMBDA(logical_array, [logical_function],
     LET(
-        logical_function, IF(ISOMITTED(logical_function), LAMBDA(x, OR(x)), logical_function),
+        logical_function, IF(
+            ISOMITTED(logical_function),
+            LAMBDA(x, OR(x)),
+            logical_function
+        ),
         BYROW(logical_array, LAMBDA(each_row, logical_function(each_row)))
     )
 );
 
 // NONE --> IS_COLUMNS_LOGICAL
 IS_COLUMNS_LOGICAL = LAMBDA(logical_array, [logical_function],
     LET(
-        logical_function, IF(ISOMITTED(logical_function), LAMBDA(x, OR(x)), logical_function),
+        logical_function, IF(
+            ISOMITTED(logical_function),
+            LAMBDA(x, OR(x)),
+            logical_function
+        ),
         BYCOL(logical_array, LAMBDA(each_col, logical_function(each_col)))
     )
 );