PROCESS

PROCESS(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty])
reference
Required. Specifies the function input and can be a cell, range, or array.
size
Optional. Specifies the number of the output rows or columns and can be a single number (integer greater than or equal to 1).
columns
Optional. Specifies whether the second parameter, i.e. "size", applies to rows or columns and takes two general arguments: 0 or omitted or FALSE, for "off" meaning that "size" refers to rows; and 1 or TRUE or any number other than 0, for "on" meaning that "size" refers to columns.
output_style
Optional. Specifies how the blank cells generated through data exclusion/inclusion are handled and takes two arguments: 0 or omitted, for removing all blank cells, if any, generated through data exclusion/inclusion; and 1, for removing only full rows or columns, if any, of blank cells generated through data exclusion/inclusion.
exclude_types
Optional. Specifies the type(s) of data that can be excluded from the main output and takes one or more of twenty-four arguments: 1, for number; 2, for text; 3, for blank; 4, for logical; 16, for error; 31, for real blank; 32, for formula blank; 41, for TRUE; 42, for FALSE; 160, for #EXTERNAL! error; 161, for #NULL! error; 162, for #DIV/0! error; 163, for #VALUE! error; 164, for #REF! error; 165, for #NAME? error; 166, for #NUM! error; 167, for #N/A error; 168, for #GETTING_DATA error; 169, for #SPILL! error; 1610, for #CONNECT! error; 1611, for #BLOCKED! error; 1612, for #UNKNOWN! error; 1613, for #FIELD! error; 1614, for #CALC! error.
include_types
Optional. Specifies the type(s) of data that can be included in the main output and takes one or more of twenty-four arguments: 1, for number; 2, for text; 3, for blank; 4, for logical; 16, for error; 31, for real blank; 32, for formula blank; 41, for TRUE; 42, for FALSE; 160, for #EXTERNAL! error; 161, for #NULL! error; 162, for #DIV/0! error; 163, for #VALUE! error; 164, for #REF! error; 165, for #NAME? error; 166, for #NUM! error; 167, for #N/A error; 168, for #GETTING_DATA error; 169, for #SPILL! error; 1610, for #CONNECT! error; 1611, for #BLOCKED! error; 1612, for #UNKNOWN! error; 1613, for #FIELD! error; 1614, for #CALC! error.
replace_with
Optional. Specifies a single entry of any desired data type (i.e. number, text, blank, logical, or error) that can be used to replace any entries that were either directly excluded via the exclude_types parameter or indirectly excluded via the include_types parameter.
if_empty
Optional. Specifies a single entry of any desired data type (i.e. number, text, blank, logical, or error) that can be displayed as the main function output if the output is empty.
PROCESS resizes any input reference into an array/range of any desired size (could be considered as the reverse of LIN/TOROW/TOCOL) with options for output size/style and full control over data type(s) inclusion/exclusion
R

Rnkhch

Well-known Member
Joined
Apr 28, 2018
Messages
528
Office Version
  1. 365
Platform
  1. Windows
PROCESS resizes any input reference into an array/range of any desired size (could be considered as the reverse of LIN/TOROW/TOCOL) with options for output size/style and full control over data type(s) inclusion/exclusion

PROCESS was developed primarily to enable resizing of the input reference into an array/range of any desired size, i.e. rows(s) and/or column(s). When the output is chosen to be two-dimensional (which is the main reason I developed the function), PROCESS can be considered as the reverse of LIN/TOROW/TOCOL; of course, the function has full flexibility for output size/dimension(s) which means that the output can be chosen to be linear, if needed, though for this purpose, LIN would be a much better choice as it provides several options for controlling the output linear array's style.

You control the output dimension(s) by specifying the "size" of one of the dimensions (i.e. either rows or columns) of the desired output array/range, and the function will automatically determine the minimum "size" of the other dimension. Note that depending on the size of the input and the size of the desired output dimension(s), the function may append one or more blank cells at the end of the array/range (towards the bottom/right) (see the first two attached XL2BB examples); I refer to these blank cells as non-core blank cells. These non-core blank cells are highlighted in gray in the provided examples, and they will never occur in more than one row in the output (i.e. they may only occur as one partial row). Note that if you specify a "size" that will result in a spill of more rows than needed to accommodate the spill, the function will automatically exclude the extra rows and generate the minimum-size spill necessary (which is the reason why non-core blank cells will never exceed one row).

Furthermore, instead of (or in addition to) determining the output dimensions of the array, you can utilize PROCESS to have full control over data type(s) inclusion/exclusion in the output spill (hence the name "process"). For this purpose, simply leave the "size" parameter unused; note that if you don't use the "size" parameter, the output spill will have the same general dimensions of the input which may, of course, auto-shrink depending on a) what data type(s) are included/excluded and b) on the "output_style"; see the parameter descriptions below. This particular way of utilizing PROCESS could be very useful if you need to prepare (i.e. "process") the input data in order to be used with any of the built-in Excel functions without having to go through the hassle of controlling data type(s) inclusion/exclusion within those functions (by writing additional code) given that Excel's built-in functions do not have this kind of straightforward/full-resolution control over data types (some built-in functions have basic data exclusion feature such as "ignore blanks" or "ignore errors", but that is rudimentary compared with the "exclude_types/include_types/replace_with" system that I have developed). Note that most of the functions that I have developed have this kind of full-resolution data "processing" control for inclusion/exclusion already built into them, so you don't need to use PROCESS with/for them.

PROCESS takes eight parameters, one required, and seven optional, as follows:
A) The first parameter, reference, required, specifies the function input and can be a cell, range, or array

Note that if none of the other parameters are utilized, the function will spill the input reference exactly in its original form

B) The second parameter, size, specifies the number of the output rows or columns and takes a single number (integer greater than or equal to 1) as argument

Note that whether "size" refers to rows or columns is controlled by the next (i.e. third) parameter, "columns", as described below

Note that if more than one number is entered through the array brackets "{}", or if any other "type" of element(s) is entered, the function will return a single #N/A

C) The third parameter, columns, optional, specifies whether the second parameter, i.e. "size", applies to rows or columns and takes two general arguments:
0 or omitted or FALSE, for "off" meaning that the "size" specified in the second parameter refers to rows
1 or TRUE or any number other than 0, for "on" meaning that the "size" specified in the second parameter refers to columns

Note that this argument structure matches the Excel's native way of handling on/off arguments for parameters and is accomplished by my PLSL module shown below

Note that if this parameter is used without using the second parameter, the function will return a single #N/A

Note that if more than one entry is included in this parameter via the array brackets "{}", the function will crash with a single #N/A

D) The fourth parameter, output_style, optional, specifies how the blank cells generated through data exclusion/inclusion are handled and takes two arguments:
0 or omitted, for removing all blank cells, if any, generated through data exclusion/inclusion
1, for removing only full rows or columns, if any, of blank cells generated through data exclusion/inclusion

Note that this parameter takes effect only if the "exclude_types" or "include_types" parameters is used and without the "replace_with" parameter (see below for descriptions). If no cells are excluded/included or if the excluded/included cells are replaced with other data through the "replace_with" parameter, then "output_style" being omitted, 0, or 1 will result in the same output spill.

Note that argument 0 or omitted attempts to be faithful to the specified "size" and it simply joins the output cells together without preserving the data structure of the unexcluded/unincluded spill, which means that cells that were in different rows of the unexcluded/unincluded spill may now appear on the same row of the excluded/included output (see attached XL2BB examples). However, argument 1 attempts to be faithful to the data structure of the unexcluded/unincluded spill, which is why it removes only full rows/columns of blank cells generated through data exclusion/inclusion. This means that the excluded/included output may not necessarily have the specified "size". Thus, the decision as to which argument to use depends on whether the "size" is more important for the particular usage or the data "structure" of the unexcluded/unincluded spill. Of course, the overall linear order of the input cells, nonetheless, is still preserved with either argument (i.e. no scrambling occurs).

Note that both arguments 0 or omitted and 1 may cause the output spill to auto-shrink. For argument 0, the auto-shrink happens at the bottom right corner of the output relative to the unexcluded/unincluded spill. For argument 1, the auto-shrink may happen for rows (upward auto-shrink) and/or columns (leftward auto-shrink) of the output relative to the unexcluded/unincluded spill (see attached XL2BB examples).

E) The fifth parameter, exclude_types, optional, specifies the type(s) of data that can be excluded from the main output and takes one or more of twenty-four arguments:
1, for number
2, for text
3, for blank
4, for logical
16, for error
31, for real blank
32, for formula blank
41, for TRUE
42, for FALSE
160, for #EXTERNAL! error
161, for #NULL! error
162, for #DIV/0! error
163, for #VALUE! error
164, for #REF! error
165, for #NAME? error
166, for #NUM! error
167, for #N/A error
168, for #GETTING_DATA error
169, for #SPILL! error
1610, for #CONNECT! error
1611, for #BLOCKED! error
1612, for #UNKNOWN! error
1613, for #FIELD! error
1614, for #CALC! error

Note that if you need to enter more than one argument, you need to use the array brackets "{}" such as {1,31} for excluding numbers and real blanks, respectively, or {16,2,4} for excluding errors, texts, and logicals, respectively; see the attached XL2BB examples (the number of types permutations is huge; I have only shown a few examples); this parameter as well as the next (include_types) allow for a remarkable level of flexibility and full resolution for managing data types in the function output

Note that excluding type(s) may cause the output spill to auto-shrink. The exact manner of auto-shrinking also depends on which "output_style" is utilized in the fourth parameter describe at section D above (see attached XL2BB examples).

Note that the numbers included in the array brackets for excluding types don't have to be in any order, as shown in the example above

Note that the same principles specified for exclude_types apply to the include_types parameter as described below in section F

F) The sixth parameter, include_types, optional, specifies the type(s) of data that can be included in the main output and takes one or more of twenty-four arguments, exactly like the fifth parameter in section E above

Note that both exclude_types and include_types cannot be used simultaneously

Note that using include_types (unless all types are included as by {1,2,3,4,16} for example) may also cause the main output spill to auto-shrink. See sections D and E above for additional information on the auto-shrink capability of the function (see attached XL2BB examples).

G) The seventh parameter, replace_with, optional, specifies a single entry of any desired data type (i.e. number, text, blank, logical, or error) that can be used to replace any entries that were either directly excluded via the exclude_types parameter or indirectly excluded via the include_types parameter

Note that if you use the replace_with parameter by itself, i.e. without using one of exclude_types or include_types, the function will crash with a single #N/A

Note that if more than one entry is included in this parameter via array brackets "{}", the function will crash with a single #N/A

Note that if replace_with is used, the function output will not auto-shrink relative to the unexcluded/unincluded spill. See sections D and E above for additional information on the auto-shrink capability of the function (see attached XL2BB examples)

H) The eighth parameter, if_empty, optional, specifies a single entry of any desired data type (i.e. number, text, blank, logical, or error) that can be displayed as the main function output if the output is empty, i.e. #CALC! with the message "Empty arrays are not supported"

Note that if the function output contains #CALC! which comes from an existing entry in the function input, then you will see the message "This #CALC! error comes from a precedent to this formula". This implies that this particular type of output is not actually "empty", and therefore, if there is an entry in the if_empty parameter, this entry will not be shown

Note that if more than one entry is included in this parameter via array brackets "{}", the function will crash with a single #N/A

Note that the "empty" status of the output as well as the use of if_empty, if supplied, is controlled by my JAI module described below (I have adopted the JXX naming pattern for my modules and helper functions as there are the fewest number of built-in Excel functions starting with the letter J)

PROCESS
VBA Code: 
=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],
   LET(
      r,IF(reference="","",reference),
      x,TOROW(r),
      y,COLUMNS(x),
      l,PLS(MIN(size,y)),
      w,XTYPE(reference,3),
      c,PLSL(columns),
      o,PLS(PO0(output_style)),
      d,ROUNDUP(y/l,0),
      z,SEQUENCE(SWITCH(c,0,l,1,d),,0,SWITCH(c,0,d,1,l))+SEQUENCE(,SWITCH(c,0,d,1,l)),
      a,CHOOSEROWS(z,SEQUENCE(SUM(BYROW(z,LAMBDA(a,IF(SUM(T1F0(a<=y)),1,0)))))),
      m,IF(IO(size),r,IF(a<=y,INDEX(x,1,a),"")),
      n,IF(IO(size),SEQUENCE(ROWS(r),COLUMNS(r)),IF(a<=y,a,"")),
      p,IF(IO(size),w,IF(a<=y,INDEX(TOROW(w),1,a),"")),
      IF(
         OR(AND(IO(size),NIO(columns)),NOT(OR(o={0,1})),MOD(size,1),NOT(ISNUMBER(size))),
         NA(),
         JAI(
            SWITCH(JAL(exclude_types,include_types,replace_with),
               0,m,
               1,SWITCH(o,
                  0,JAR(exclude_types,include_types,replace_with,m,p),
                  1,JAF(n,exclude_types,include_types,replace_with,m,p))),
            if_empty
         )
      )
   )
)

XERROR.TYPE (posted separately)

XTYPE (posted separately)

JAB (returns a number greater than or equal to 1 (i.e. TRUE) if the reference has the specified data type(s) and 0 (i.e. FALSE) otherwise)
VBA Code: 
=LAMBDA(types,advanced_types_array,
   IF(SUM(T1F0(ISERROR(MATCH(types,AllTypes,0)))),
   NA(),
   LET(
      basic_types_array,SWITCH(advanced_types_array,1,1,2,2,31,3,32,3,41,4,42,4,"","",16),
      MAP(advanced_types_array,LAMBDA(a,OR(a=types)))+MAP(basic_types_array,LAMBDA(a,OR(a=types)))
   )
   )
)

JAF (module for 2D "exclude_types/include_types/replace_with" when spill includes non-core blank cells)
VBA Code: 
=LAMBDA(core_output,exclude_types,include_types,replace_with,main_array,advanced_types_array,
   LET(
      c,IF(IO(include_types),exclude_types,include_types),
      w,IF(ISNUMBER(core_output),1,0),
      x,JAB(c,advanced_types_array),
      m,IF(
         IO(include_types),
         IF(w*x,IF(IO(replace_with),"",replace_with),main_array),
         IF(w*x,main_array,IF(IO(replace_with),"",IF(w,replace_with,"")))),
      IF(IO(replace_with),JAH(core_output,x,m,include_types),m)
   )
)

JAH (removes rows and columns containing non-core blank cells)
VBA Code: 
=LAMBDA(core_cells,treated_cells,treated_output,include_types,
   LET(
      c,core_cells,
      t,treated_cells,
      m,IF(ISNUMBER(c),1,0),
      d,IF(IF(IO(include_types),t*m,t),1,0),
      i,IF(IO(include_types),m-d,d),
      e,(IF(BYROW(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(ROWS(c))),
      o,FILTER(e,e),
      f,(IF(BYCOL(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(,COLUMNS(c))),
      p,FILTER(f,f),
      CHOOSECOLS(CHOOSEROWS(treated_output,o),p)
   )
)

JAI (module for "if_empty")
VBA Code: 
=LAMBDA(operation,if_empty,
   IF(
      JAN(if_empty),
      NA(),
      LET(
         e,IF(ISERROR(operation),IF(ERROR.TYPE(operation)=14,1,0),0),
         f,IF(ISERROR(ROWS(operation)*COLUMNS(operation)),1,0),
         IF(
            e+f=2,
            IF(IO(if_empty),operation,if_empty),
            operation
         )
      )
   )
)

JAL (switch for "include_types/exclude_types")
VBA Code: 
=LAMBDA(exclude_types,include_types,replace_with,
   IF(
      JAN(replace_with),
      NA(),
      IFS(
         AND(IO(exclude_types),IO(include_types),IO(replace_with)),0,
         OR(AND(IO(include_types),NIO(exclude_types)),AND(NIO(include_types),IO(exclude_types))),1
      )
   )
)

JAN (Returns TRUE if the reference is an array (i.e. is not a single element or is not omitted) and FALSE otherwise [simplified form of ISARRAY])
VBA Code: 
=LAMBDA([reference],
   LET(
      r,IFERROR(IF(reference="","",reference),""),
      IF(
         IO(reference),
         FALSE,
         IF(ROWS(r)*COLUMNS(r)>1,TRUE,FALSE)
      )
   )
)

JAO (Returns TRUE if the reference contains at least one error and FALSE otherwise [simplified form of ISERRORS])
VBA Code: 
=LAMBDA(reference,
   IF(
      IO(reference),
      FALSE,
      IF(SUM(IF(ISERROR(reference),1,0)),TRUE,FALSE)
   )
)

JAP (Returns TRUE if the reference contains at least one blank and FALSE otherwise [simplified form of ISBLANKS])
VBA Code: 
=LAMBDA(reference,
   IF(
      IO(reference),
      NA(),
      IF(SUM(IF(IFERROR(reference,0)="",1,0)),TRUE,FALSE)
   )
)

JAR (module for 2D "exclude_types/include_types/replace_with" removing all blank cells generated by the exclusion/inclusion)
VBA Code: 
=LAMBDA(exclude_types,include_types,replace_with,main_array,advanced_types_array,
   LET(
      c,IF(IO(include_types),exclude_types,include_types),
      w,IF(advanced_types_array="","",JAB(c,advanced_types_array)),
      x,LET(
         a,IF(IO(include_types),IFERROR(IF(w,0,1),""),w),
         IF(a=0,"",a)),
      y,LET(
         b,COUNT(x),
         a,SEQUENCE(ROUNDUP(b/COLUMNS(x),0),MIN(b,COLUMNS(x))),
         IF(a>b,"",a)),
      z,IF(
         IO(replace_with),
         FILTER(TOROW(main_array),TOROW(x)<>""),
         IF((x="")*(ISNUMBER(w)),replace_with,main_array)),
      IF(
         IO(replace_with),
         IF(ISNUMBER(y),INDEX(z,1,y),y),
         z
      )
   )
)

PLS (stands for "parameter limit, single")
(Returns the parameter if it is a single entry (not blank or error) and #N/A otherwise)
(Causes the function to crash to a single #N/A if the incorrect parameter is entered [either the wrong type or more than a single entry in array brackets "{}"])
VBA Code: 
=LAMBDA(parameter,
   INDEX(
      IF(OR(JAN(parameter),JAO(parameter),JAP(parameter)),NA(),parameter),
      1
   )
)

PLSL (stands for "parameter limit, single logical)
(Returns 1 if the parameter is a single TRUE entry; 0 if the parameter is a single FALSE entry or is omitted; and #N/A otherwise)
(Causes the function to crash to a single #N/A if incorrect parameters are entered [either anything not capable of being evaluated logically or more than a single entry in array brackets "{}"]))
VBA Code: 
=LAMBDA([parameter],
   IF(
      IO(parameter),
      0,
      IF(
         JAN(parameter),
         NA(),
         LET(
            p,INDEX(parameter,1),
            IF(ISERROR(p),NA(),T1F0(p))
         )
      )
   )
)

IO (shortened form of ISOMITTED)
VBA Code: 
=LAMBDA(parameter,
   ISOMITTED(parameter)
)

NIO [shortened form of NOT(ISOMITTED)]
VBA Code: 
=LAMBDA(parameter,
   NOT(ISOMITTED(parameter))
)

PO0 (Returns 0 if the parameter is omitted and the parameter itself otherwise)
VBA Code: 
=LAMBDA([parameter],
   IF(IO(parameter),0,parameter)
)

T1F0 (Returns 1 if the reference is TRUE, 0 if the reference is FALSE, and #N/A otherwise)
VBA Code: 
=LAMBDA(expression,
   IF(
      ISNUMBER(expression)+ISLOGICAL(expression),
      IF(expression,1,0),
      NA())
)

AllTypes
VBA Code: 
={1,2,3,4,16,31,32,41,42,160,161,162,163,164,165,166,167,168,169,1610,1611,1612,1613,1614}

Here are all the modules in the XL2BB format for easier transfer (note that these are the most up-to-date versions compared with the same modules from my previous posts for other functions that may contain older versions):
PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWXYZAA
1
2PROCESS#CALC!
3XTYPE#CALC!
4XERROR.TYPE#CALC!
5IO#CALC!
6JAB#CALC!
7JAF#CALC!
8JAH#CALC!
9JAI#CALC!
10JAL#CALC!
11JAN#CALC!
12JAO#CALC!
13JAP#CALC!
14JAR#CALC!
15NIO#CALC!
16PLS#CALC!
17PLSL#CALC!
18PO0#CALC!
19T1F0#CALC!
20AllTypes1234163132414216016116216316416516616716816916101611161216131614
21
Sheet1
Cell Formulas
RangeFormula
C2C2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),x,TOROW(r),y,COLUMNS(x),l,PLS(MIN(size,y)),w,XTYPE(reference,3),c,PLSL(columns),o,PLS(PO0(output_style)),d,ROUNDUP(y/l,0),z,SEQUENCE(SWITCH(c,0,l,1,d),,0,SWITCH(c,0,d,1,l))+SEQUENCE(,SWITCH(c,0,d,1,l)),a,CHOOSEROWS(z,SEQUENCE(SUM(BYROW(z,LAMBDA(a,IF(SUM(T1F0(a<=y)),1,0)))))),m,IF(IO(size),r,IF(a<=y,INDEX(x,1,a),"")),n,IF(IO(size),SEQUENCE(ROWS(r),COLUMNS(r)),IF(a<=y,a,"")),p,IF(IO(size),w,IF(a<=y,INDEX(TOROW(w),1,a),"")),IF(OR(AND(IO(size),NIO(columns)),NOT(OR(o={0,1})),MOD(size,1),NOT(ISNUMBER(size))),NA(),JAI(SWITCH(JAL(exclude_types,include_types,replace_with),0,m,1,SWITCH(o,0,JAR(exclude_types,include_types,replace_with,m,p),1,JAF(n,exclude_types,include_types,replace_with,m,p))),if_empty))))
C3C3=LAMBDA(reference,[analysis_type],IF(IO(reference),NA(),LET(r,reference,a,PLS(PO0(analysis_type)),IF(OR(a={0,1,2,3}),LET(z,MAP(r,LAMBDA(b,IF(ISERROR(b),XERROR.TYPE(b),IF(b="",IF(ISBLANK(b),31,32),IF(ISNUMBER(b),1,IF(ISTEXT(b),2,IF(b,41,42))))))),SWITCH(a,0,SWITCH(z,1,"dt:NUMBER",2,"dt:TEXT",31,"dt:BLANK",32,"dt:BLANK",41,"dt:LOGICAL",42,"dt:LOGICAL","dt:ERROR"),1,SWITCH(z,1,"dt:NUMBER",2,"dt:TEXT",31,"dt:BLANK_REAL",32,"dt:BLANK_FORMULA",41,"dt:LOGICAL_TRUE",42,"dt:LOGICAL_FALSE",160,"dt:ERROR_EXTERNAL!",161,"dt:ERROR_NULL!",162,"dt:ERROR_DIV/0!",163,"dt:ERROR_VALUE!",164,"dt:ERROR_REF!",165,"dt:ERROR_NAME?",166,"dt:ERROR_NUM!",167,"dt:ERROR_N/A",168,"dt:ERROR_GETTING_Data",169,"dt:ERROR_SPILL!",1610,"dt:ERROR_CONNECT!",1611,"dt:ERROR_BLOCKED!",1612,"dt:ERROR_UNKNOWN!",1613,"dt:ERROR_FIELD!",1614,"dt:ERROR_CALC!"),2,SWITCH(z,1,1,2,2,31,3,32,3,41,4,42,4,16),3,z)),LET(t,MAP(r,LAMBDA(u,IF(OR(a={4,5}),TYPE(u),CELL("type",u)))),SWITCH(a,4,t,5,SWITCH(t,1,"dt:NUMBER",2,"dt:TEXT",4,"dt:LOGICAL",16,"dt:ERROR"),6,t))))))
C4C4=LAMBDA(reference,[analysis_type],[if_not_error],IF(IO(reference),NA(),LET(a,PLS(PO0(analysis_type)),o,SWITCH(a,0,SWITCH(ERROR.TYPE(reference),0,160,1,161,2,162,3,163,4,164,5,165,6,166,7,167,8,168,9,169,10,1610,11,1611,12,1612,13,1613,14,1614),1,SWITCH(ERROR.TYPE(reference),0,"dt:ERROR_EXTERNAL!",1,"dt:ERROR_NULL!",2,"dt:ERROR_DIV/0!",3,"dt:ERROR_VALUE!",4,"dt:ERROR_REF!",5,"dt:ERROR_NAME?",6,"dt:ERROR_NUM!",7,"dt:ERROR_N/A",8,"dt:ERROR_GETTING_Data",9,"dt:ERROR_SPILL!",10,"dt:ERROR_CONNECT!",11,"dt:ERROR_BLOCKED!",12,"dt:ERROR_UNKNOWN!",13,"dt:ERROR_FIELD!",14,"dt:ERROR_CALC!"),2,ERROR.TYPE(reference)),IF(ISERROR(a),o,IF(JAN(if_not_error),NA(),IF(IO(if_not_error),o,IF(ISERROR(o),if_not_error,o)))))))
C5C5=LAMBDA(parameter,ISOMITTED(parameter))
C6C6=LAMBDA(types,advanced_types_array,IF(SUM(T1F0(ISERROR(MATCH(types,AllTypes,0)))),NA(),LET(basic_types_array,SWITCH(advanced_types_array,1,1,2,2,31,3,32,3,41,4,42,4,"","",16),MAP(advanced_types_array,LAMBDA(a,OR(a=types)))+MAP(basic_types_array,LAMBDA(a,OR(a=types))))))
C7C7=LAMBDA(core_output,exclude_types,include_types,replace_with,main_array,advanced_types_array,LET(c,IF(IO(include_types),exclude_types,include_types),w,IF(ISNUMBER(core_output),1,0),x,JAB(c,advanced_types_array),m,IF(IO(include_types),IF(w*x,IF(IO(replace_with),"",replace_with),main_array),IF(w*x,main_array,IF(IO(replace_with),"",IF(w,replace_with,"")))),IF(IO(replace_with),JAH(core_output,x,m,include_types),m)))
C8C8=LAMBDA(core_cells,treated_cells,treated_output,include_types,LET(c,core_cells,t,treated_cells,m,IF(ISNUMBER(c),1,0),d,IF(IF(IO(include_types),t*m,t),1,0),i,IF(IO(include_types),m-d,d),e,(IF(BYROW(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(ROWS(c))),o,FILTER(e,e),f,(IF(BYCOL(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(,COLUMNS(c))),p,FILTER(f,f),CHOOSECOLS(CHOOSEROWS(treated_output,o),p)))
C9C9=LAMBDA(operation,if_empty,IF(JAN(if_empty),NA(),LET(e,IF(ISERROR(operation),IF(ERROR.TYPE(operation)=14,1,0),0),f,IF(ISERROR(ROWS(operation)*COLUMNS(operation)),1,0),IF(e+f=2,IF(IO(if_empty),operation,if_empty),operation))))
C10C10=LAMBDA(exclude_types,include_types,replace_with,IF(JAN(replace_with),NA(),IFS(AND(IO(exclude_types),IO(include_types),IO(replace_with)),0,OR(AND(IO(include_types),NIO(exclude_types)),AND(NIO(include_types),IO(exclude_types))),1)))
C11C11=LAMBDA([reference],LET(r,IFERROR(IF(reference="","",reference),""),IF(IO(reference),FALSE,IF(ROWS(r)*COLUMNS(r)>1,TRUE,FALSE))))
C12C12=LAMBDA(reference,IF(IO(reference),FALSE,IF(SUM(IF(ISERROR(reference),1,0)),TRUE,FALSE)))
C13C13=LAMBDA(reference,IF(IO(reference),NA(),IF(SUM(IF(IFERROR(reference,0)="",1,0)),TRUE,FALSE)))
C14C14=LAMBDA(exclude_types,include_types,replace_with,main_array,advanced_types_array,LET(c,IF(IO(include_types),exclude_types,include_types),w,IF(advanced_types_array="","",JAB(c,advanced_types_array)),x,LET(a,IF(IO(include_types),IFERROR(IF(w,0,1),""),w),IF(a=0,"",a)),y,LET(b,COUNT(x),a,SEQUENCE(ROUNDUP(b/COLUMNS(x),0),MIN(b,COLUMNS(x))),IF(a>b,"",a)),z,IF(IO(replace_with),FILTER(TOROW(main_array),TOROW(x)<>""),IF((x="")*(ISNUMBER(w)),replace_with,main_array)),IF(IO(replace_with),IF(ISNUMBER(y),INDEX(z,1,y),y),z)))
C15C15=LAMBDA(parameter,NOT(ISOMITTED(parameter)))
C16C16=LAMBDA(parameter,INDEX(IF(OR(JAN(parameter),JAO(parameter),JAP(parameter)),NA(),parameter),1))
C17C17=LAMBDA([parameter],IF(IO(parameter),0,IF(JAN(parameter),NA(),LET(p,INDEX(parameter,1),IF(ISERROR(p),NA(),T1F0(p))))))
C18C18=LAMBDA([parameter],IF(IO(parameter),0,parameter))
C19C19=LAMBDA(expression,IF(ISNUMBER(expression)+ISLOGICAL(expression),IF(expression,1,0),NA()))
C20:Z20C20={1,2,3,4,16,31,32,41,42,160,161,162,163,164,165,166,167,168,169,1610,1611,1612,1613,1614}
Dynamic array formulas.


General demo, with "size" for rows:
PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1
2#CALC!
3
453bookTRUE32#DIV/0!a67
523.6778notebookTRUE0.543b
6#CALC! 17FALSE#REF!
7
8
9lengthcolumnsoutput_styleoutput
101omittedomitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
112omittedomitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebook
12TRUE0.543b#CALC!17FALSE#REF!
133omittedomitted or 0 or 153bookTRUE32#DIV/0!a67
1423.6778notebookTRUE0.543b
15#CALC!17FALSE#REF!
164omittedomitted or 0 or 153bookTRUE32#DIV/0!a
176723.6778notebookTRUE
180.543b#CALC!17FALSE
19#REF!
205omittedomitted or 0 or 153bookTRUE32#DIV/0!
21a6723.6778
22notebookTRUE0.543b#CALC!
2317FALSE#REF!
24
256omittedomitted or 0 or 153bookTRUE32
26#DIV/0!a6723.67
2778notebookTRUE
280.543b#CALC!
2917FALSE#REF!
30
317omittedomitted or 0 or 153bookTRUE
3232#DIV/0!a
336723.6778
34notebookTRUE
350.543b#CALC!
3617FALSE
37#REF!
388 or 9 or 10omittedomitted or 0 or 153bookTRUE53bookTRUE53bookTRUE
3932#DIV/0!a32#DIV/0!a32#DIV/0!a
406723.67786723.67786723.6778
41notebookTRUEnotebookTRUEnotebookTRUE
420.543b#CALC!0.543b#CALC!0.543b#CALC!
4317FALSE17FALSE17FALSE
44#REF!#REF!#REF!
4511 or 12 or 13 or 14 or 15 or 16 or 17 or 18 or 19 or 20omittedomitted or 0 or 153book53book53book
46TRUE32TRUE32TRUE32
47#DIV/0!a#DIV/0!a#DIV/0!a
486723.676723.676723.67
49787878
50notebookTRUEnotebookTRUEnotebookTRUE
510.543b0.543b0.543b
52#CALC!#CALC!#CALC!
5317FALSE17FALSE17FALSE
54#REF!#REF!#REF!
55
5621 or greateromittedomitted or 0 or 1535353535353535353
57bookbookbookbookbookbookbookbookbook
58TRUETRUETRUETRUETRUETRUETRUETRUETRUE
59323232323232323232
60#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!
61aaaaaaaaa
62676767676767676767
6323.6723.6723.6723.6723.6723.6723.6723.6723.67
64787878787878787878
65
66notebooknotebooknotebooknotebooknotebooknotebooknotebooknotebooknotebook
67TRUETRUETRUETRUETRUETRUETRUETRUETRUE
680.5430.5430.5430.5430.5430.5430.5430.5430.543
69bbbbbbbbb
70#CALC!#CALC!#CALC!#CALC!#CALC!#CALC!#CALC!#CALC!#CALC!
71
72171717171717171717
73FALSEFALSEFALSEFALSEFALSEFALSEFALSEFALSEFALSE
74
75#REF!#REF!#REF!#REF!#REF!#REF!#REF!#REF!#REF!
76
77
res-r
Cell Formulas
RangeFormula
B2B2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),x,TOROW(r),y,COLUMNS(x),l,PLS(MIN(size,y)),w,XTYPE(reference,3),c,PLSL(columns),o,PLS(PO0(output_style)),d,ROUNDUP(y/l,0),z,SEQUENCE(SWITCH(c,0,l,1,d),,0,SWITCH(c,0,d,1,l))+SEQUENCE(,SWITCH(c,0,d,1,l)),a,CHOOSEROWS(z,SEQUENCE(SUM(BYROW(z,LAMBDA(a,IF(SUM(T1F0(a<=y)),1,0)))))),m,IF(IO(size),r,IF(a<=y,INDEX(x,1,a),"")),n,IF(IO(size),SEQUENCE(ROWS(r),COLUMNS(r)),IF(a<=y,a,"")),p,IF(IO(size),w,IF(a<=y,INDEX(TOROW(w),1,a),"")),IF(OR(AND(IO(size),NIO(columns)),NOT(OR(o={0,1})),MOD(size,1),NOT(ISNUMBER(size))),NA(),JAI(SWITCH(JAL(exclude_types,include_types,replace_with),0,m,1,SWITCH(o,0,JAR(exclude_types,include_types,replace_with,m,p),1,JAF(n,exclude_types,include_types,replace_with,m,p))),if_empty))))
F4F4=1/0
C6C6=IF(1,"")
E10:Y10E10=PROCESS($B$4:$H$6,1)
E11:O12E11=PROCESS($B$4:$H$6,2)
E13:K15E13=PROCESS($B$4:$H$6,3)
E16:J19E16=PROCESS($B$4:$H$6,4)
E20:I24E20=PROCESS($B$4:$H$6,5)
E25:H30E25=PROCESS($B$4:$H$6,6)
E31:G37E31=PROCESS($B$4:$H$6,7)
E38:G44E38=PROCESS($B$4:$H$6,8)
H38:J44H38=PROCESS($B$4:$H$6,9)
K38:M44K38=PROCESS($B$4:$H$6,10)
E45:F55E45=PROCESS($B$4:$H$6,11)
G45:H55G45=PROCESS($B$4:$H$6,15)
I45:J55I45=PROCESS($B$4:$H$6,20)
E56:E76E56=PROCESS($B$4:$H$6,21)
F56:F76F56=PROCESS($B$4:$H$6,22)
G56:G76G56=PROCESS($B$4:$H$6,30)
I56:I76I56=PROCESS($B$4:$H$6,21,,0)
J56:J76J56=PROCESS($B$4:$H$6,22,,0)
K56:K76K56=PROCESS($B$4:$H$6,30,,0)
M56:M76M56=PROCESS($B$4:$H$6,21,,1)
N56:N76N56=PROCESS($B$4:$H$6,22,,1)
O56:O76O56=PROCESS($B$4:$H$6,30,,1)
Dynamic array formulas.
 
Upvote 0
General demo, with "size" for columns:
PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1
2#CALC!
3
453bookTRUE32#DIV/0!a67
523.6778notebookTRUE0.543b
6#CALC! 17FALSE#REF!
7
8
9lengthcolumnsoutput_styleoutput
1011omitted or 0 or 153
11book
12TRUE
1332
14#DIV/0!
15a
1667
1723.67
1878
19
20notebook
21TRUE
220.543
23b
24#CALC!
25
2617
27FALSE
28
29#REF!
30
3121omitted or 0 or 153book
32TRUE32
33#DIV/0!a
346723.67
3578
36notebookTRUE
370.543b
38#CALC!
3917FALSE
40#REF!
41
4231omitted or 0 or 153bookTRUE
4332#DIV/0!a
446723.6778
45notebookTRUE
460.543b#CALC!
4717FALSE
48#REF!
4941omitted or 0 or 153bookTRUE32
50#DIV/0!a6723.67
5178notebookTRUE
520.543b#CALC!
5317FALSE#REF!
54
5551omitted or 0 or 153bookTRUE32#DIV/0!
56a6723.6778
57notebookTRUE0.543b#CALC!
5817FALSE#REF!
59
6061omitted or 0 or 153bookTRUE32#DIV/0!a
616723.6778notebookTRUE
620.543b#CALC!17FALSE
63#REF!
6471omitted or 0 or 153bookTRUE32#DIV/0!a67
6523.6778notebookTRUE0.543b
66#CALC!17FALSE#REF!
6781omitted or 0 or 153bookTRUE32#DIV/0!a6723.67
6878notebookTRUE0.543b#CALC!
6917FALSE#REF!
7091omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778
71notebookTRUE0.543b#CALC!17FALSE
72#REF!
73101omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778
74notebookTRUE0.543b#CALC!17FALSE#REF!
75
76111omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebook
77TRUE0.543b#CALC!17FALSE#REF!
78121omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE
790.543b#CALC!17FALSE#REF!
80131omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543
81b#CALC!17FALSE#REF!
82141omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b
83#CALC!17FALSE#REF!
84151omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!
8517FALSE#REF!
86161omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!
8717FALSE#REF!
88171omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17
89FALSE#REF!
90181omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE
91#REF!
92191omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE
93#REF!
94201omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
95
96211omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
97221omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
98301omitted or 0 or 153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
99
res-c
Cell Formulas
RangeFormula
B2B2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),x,TOROW(r),y,COLUMNS(x),l,PLS(MIN(size,y)),w,XTYPE(reference,3),c,PLSL(columns),o,PLS(PO0(output_style)),d,ROUNDUP(y/l,0),z,SEQUENCE(SWITCH(c,0,l,1,d),,0,SWITCH(c,0,d,1,l))+SEQUENCE(,SWITCH(c,0,d,1,l)),a,CHOOSEROWS(z,SEQUENCE(SUM(BYROW(z,LAMBDA(a,IF(SUM(T1F0(a<=y)),1,0)))))),m,IF(IO(size),r,IF(a<=y,INDEX(x,1,a),"")),n,IF(IO(size),SEQUENCE(ROWS(r),COLUMNS(r)),IF(a<=y,a,"")),p,IF(IO(size),w,IF(a<=y,INDEX(TOROW(w),1,a),"")),IF(OR(AND(IO(size),NIO(columns)),NOT(OR(o={0,1})),MOD(size,1),NOT(ISNUMBER(size))),NA(),JAI(SWITCH(JAL(exclude_types,include_types,replace_with),0,m,1,SWITCH(o,0,JAR(exclude_types,include_types,replace_with,m,p),1,JAF(n,exclude_types,include_types,replace_with,m,p))),if_empty))))
F4F4=1/0
C6C6=IF(1,"")
E10:E30E10=PROCESS($B$4:$H$6,1,1)
E31:F41E31=PROCESS($B$4:$H$6,2,1)
E42:G48E42=PROCESS($B$4:$H$6,3,1)
E49:H54E49=PROCESS($B$4:$H$6,4,1)
E55:I59E55=PROCESS($B$4:$H$6,5,1)
E60:J63E60=PROCESS($B$4:$H$6,6,1)
E64:K66E64=PROCESS($B$4:$H$6,7,1)
E67:L69E67=PROCESS($B$4:$H$6,8,1)
E70:M72E70=PROCESS($B$4:$H$6,9,1)
E73:N75E73=PROCESS($B$4:$H$6,10,1)
E76:O77E76=PROCESS($B$4:$H$6,11,1)
E78:P79E78=PROCESS($B$4:$H$6,12,1)
E80:Q81E80=PROCESS($B$4:$H$6,13,1)
E82:R83E82=PROCESS($B$4:$H$6,14,1)
E84:S85E84=PROCESS($B$4:$H$6,15,1)
E86:T87E86=PROCESS($B$4:$H$6,16,1)
E88:U89E88=PROCESS($B$4:$H$6,17,1)
E90:V91E90=PROCESS($B$4:$H$6,18,1)
E92:W93E92=PROCESS($B$4:$H$6,19,1)
E94:X95E94=PROCESS($B$4:$H$6,20,1)
E96:Y96E96=PROCESS($B$4:$H$6,21,1)
E97:Y97E97=PROCESS($B$4:$H$6,22,1)
E98:Y98E98=PROCESS($B$4:$H$6,30,1)
Dynamic array formulas.
 
Update: fixes the minor bug in the code for PROCESS that caused the function to return an #N/A when the "size" parameter was omitted

Here are all the modules in the XL2BB format for easier transfer:
PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWXYZAA
1
2PROCESS#CALC!
3XTYPE#CALC!
4XERROR.TYPE#CALC!
5IO#CALC!
6JAB#CALC!
7JAF#CALC!
8JAH#CALC!
9JAI#CALC!
10JAL#CALC!
11JAN#CALC!
12JAO#CALC!
13JAP#CALC!
14JAR#CALC!
15NIO#CALC!
16PLS#CALC!
17PLSL#CALC!
18PO0#CALC!
19T1F0#CALC!
20AllTypes1234163132414216016116216316416516616716816916101611161216131614
21
Sheet1
Cell Formulas
RangeFormula
C2C2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),x,TOROW(r),y,COLUMNS(x),l,PLS(MIN(size,y)),w,XTYPE(reference,3),c,PLSL(columns),o,PLS(PO0(output_style)),d,ROUNDUP(y/l,0),z,SEQUENCE(SWITCH(c,0,l,1,d),,0,SWITCH(c,0,d,1,l))+SEQUENCE(,SWITCH(c,0,d,1,l)),a,CHOOSEROWS(z,SEQUENCE(SUM(BYROW(z,LAMBDA(a,IF(SUM(T1F0(a<=y)),1,0)))))),m,IF(IO(size),r,IF(a<=y,INDEX(x,1,a),"")),n,IF(IO(size),SEQUENCE(ROWS(r),COLUMNS(r)),IF(a<=y,a,"")),p,IF(IO(size),w,IF(a<=y,INDEX(TOROW(w),1,a),"")),IF(OR(AND(IO(size),NIO(columns)),NOT(OR(o={0,1})),IF(IO(size),0,MOD(size,1)),IF(IO(size),0,NOT(ISNUMBER(size)))),NA(),JAI(SWITCH(JAL(exclude_types,include_types,replace_with),0,m,1,SWITCH(o,0,JAR(exclude_types,include_types,replace_with,m,p),1,JAF(n,exclude_types,include_types,replace_with,m,p))),if_empty))))
C3C3=LAMBDA(reference,[analysis_type],IF(IO(reference),NA(),LET(r,reference,a,PLS(PO0(analysis_type)),IF(OR(a={0,1,2,3}),LET(z,MAP(r,LAMBDA(b,IF(ISERROR(b),XERROR.TYPE(b),IF(b="",IF(ISBLANK(b),31,32),IF(ISNUMBER(b),1,IF(ISTEXT(b),2,IF(b,41,42))))))),SWITCH(a,0,SWITCH(z,1,"dt:NUMBER",2,"dt:TEXT",31,"dt:BLANK",32,"dt:BLANK",41,"dt:LOGICAL",42,"dt:LOGICAL","dt:ERROR"),1,SWITCH(z,1,"dt:NUMBER",2,"dt:TEXT",31,"dt:BLANK_REAL",32,"dt:BLANK_FORMULA",41,"dt:LOGICAL_TRUE",42,"dt:LOGICAL_FALSE",160,"dt:ERROR_EXTERNAL!",161,"dt:ERROR_NULL!",162,"dt:ERROR_DIV/0!",163,"dt:ERROR_VALUE!",164,"dt:ERROR_REF!",165,"dt:ERROR_NAME?",166,"dt:ERROR_NUM!",167,"dt:ERROR_N/A",168,"dt:ERROR_GETTING_Data",169,"dt:ERROR_SPILL!",1610,"dt:ERROR_CONNECT!",1611,"dt:ERROR_BLOCKED!",1612,"dt:ERROR_UNKNOWN!",1613,"dt:ERROR_FIELD!",1614,"dt:ERROR_CALC!"),2,SWITCH(z,1,1,2,2,31,3,32,3,41,4,42,4,16),3,z)),LET(t,MAP(r,LAMBDA(u,IF(OR(a={4,5}),TYPE(u),CELL("type",u)))),SWITCH(a,4,t,5,SWITCH(t,1,"dt:NUMBER",2,"dt:TEXT",4,"dt:LOGICAL",16,"dt:ERROR"),6,t))))))
C4C4=LAMBDA(reference,[analysis_type],[if_not_error],IF(IO(reference),NA(),LET(a,PLS(PO0(analysis_type)),o,SWITCH(a,0,SWITCH(ERROR.TYPE(reference),0,160,1,161,2,162,3,163,4,164,5,165,6,166,7,167,8,168,9,169,10,1610,11,1611,12,1612,13,1613,14,1614),1,SWITCH(ERROR.TYPE(reference),0,"dt:ERROR_EXTERNAL!",1,"dt:ERROR_NULL!",2,"dt:ERROR_DIV/0!",3,"dt:ERROR_VALUE!",4,"dt:ERROR_REF!",5,"dt:ERROR_NAME?",6,"dt:ERROR_NUM!",7,"dt:ERROR_N/A",8,"dt:ERROR_GETTING_Data",9,"dt:ERROR_SPILL!",10,"dt:ERROR_CONNECT!",11,"dt:ERROR_BLOCKED!",12,"dt:ERROR_UNKNOWN!",13,"dt:ERROR_FIELD!",14,"dt:ERROR_CALC!"),2,ERROR.TYPE(reference)),IF(ISERROR(a),o,IF(JAN(if_not_error),NA(),IF(IO(if_not_error),o,IF(ISERROR(o),if_not_error,o)))))))
C5C5=LAMBDA(parameter,ISOMITTED(parameter))
C6C6=LAMBDA(types,advanced_types_array,IF(SUM(T1F0(ISERROR(MATCH(types,AllTypes,0)))),NA(),LET(basic_types_array,SWITCH(advanced_types_array,1,1,2,2,31,3,32,3,41,4,42,4,"","",16),MAP(advanced_types_array,LAMBDA(a,OR(a=types)))+MAP(basic_types_array,LAMBDA(a,OR(a=types))))))
C7C7=LAMBDA(core_output,exclude_types,include_types,replace_with,main_array,advanced_types_array,LET(c,IF(IO(include_types),exclude_types,include_types),w,IF(ISNUMBER(core_output),1,0),x,JAB(c,advanced_types_array),m,IF(IO(include_types),IF(w*x,IF(IO(replace_with),"",replace_with),main_array),IF(w*x,main_array,IF(IO(replace_with),"",IF(w,replace_with,"")))),IF(IO(replace_with),JAH(core_output,x,m,include_types),m)))
C8C8=LAMBDA(core_cells,treated_cells,treated_output,include_types,LET(c,core_cells,t,treated_cells,m,IF(ISNUMBER(c),1,0),d,IF(IF(IO(include_types),t*m,t),1,0),i,IF(IO(include_types),m-d,d),e,(IF(BYROW(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(ROWS(c))),o,FILTER(e,e),f,(IF(BYCOL(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(,COLUMNS(c))),p,FILTER(f,f),CHOOSECOLS(CHOOSEROWS(treated_output,o),p)))
C9C9=LAMBDA(operation,if_empty,IF(JAN(if_empty),NA(),LET(e,IF(ISERROR(operation),IF(ERROR.TYPE(operation)=14,1,0),0),f,IF(ISERROR(ROWS(operation)*COLUMNS(operation)),1,0),IF(e+f=2,IF(IO(if_empty),operation,if_empty),operation))))
C10C10=LAMBDA(exclude_types,include_types,replace_with,IF(JAN(replace_with),NA(),IFS(AND(IO(exclude_types),IO(include_types),IO(replace_with)),0,OR(AND(IO(include_types),NIO(exclude_types)),AND(NIO(include_types),IO(exclude_types))),1)))
C11C11=LAMBDA([reference],LET(r,IFERROR(IF(reference="","",reference),""),IF(IO(reference),FALSE,IF(ROWS(r)*COLUMNS(r)>1,TRUE,FALSE))))
C12C12=LAMBDA(reference,IF(IO(reference),FALSE,IF(SUM(IF(ISERROR(reference),1,0)),TRUE,FALSE)))
C13C13=LAMBDA(reference,IF(IO(reference),NA(),IF(SUM(IF(IFERROR(reference,0)="",1,0)),TRUE,FALSE)))
C14C14=LAMBDA(exclude_types,include_types,replace_with,main_array,advanced_types_array,LET(c,IF(IO(include_types),exclude_types,include_types),w,IF(advanced_types_array="","",JAB(c,advanced_types_array)),x,LET(a,IF(IO(include_types),IFERROR(IF(w,0,1),""),w),IF(a=0,"",a)),y,LET(b,COUNT(x),a,SEQUENCE(ROUNDUP(b/COLUMNS(x),0),MIN(b,COLUMNS(x))),IF(a>b,"",a)),z,IF(IO(replace_with),FILTER(TOROW(main_array),TOROW(x)<>""),IF((x="")*(ISNUMBER(w)),replace_with,main_array)),IF(IO(replace_with),IF(ISNUMBER(y),INDEX(z,1,y),y),z)))
C15C15=LAMBDA(parameter,NOT(ISOMITTED(parameter)))
C16C16=LAMBDA(parameter,INDEX(IF(OR(JAN(parameter),JAO(parameter),JAP(parameter)),NA(),parameter),1))
C17C17=LAMBDA([parameter],IF(IO(parameter),0,IF(JAN(parameter),NA(),LET(p,INDEX(parameter,1),IF(ISERROR(p),NA(),T1F0(p))))))
C18C18=LAMBDA([parameter],IF(IO(parameter),0,parameter))
C19C19=LAMBDA(expression,IF(ISNUMBER(expression)+ISLOGICAL(expression),IF(expression,1,0),NA()))
C20:Z20C20={1,2,3,4,16,31,32,41,42,160,161,162,163,164,165,166,167,168,169,1610,1611,1612,1613,1614}
Dynamic array formulas.
 
Update: fixes the bug that affected the row count of the output with output_style 0 or omitted when type(s) were excluded or included

Also I rewrote the PROCESS code for more efficiency and integrated the JAR code into the PROCESS code. I added the module PLSN that checks for the parameter to be a natural number (i.e. an integer greater than zero) and returns an #NA otherwise.

Here are all the modules in the XL2BB format for easier transfer:
PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWXYZAA
1
2PROCESS#CALC!
3XTYPE#CALC!
4XERROR.TYPE#CALC!
5IO#CALC!
6JAB#CALC!
7JAF#CALC!
8JAH#CALC!
9JAI#CALC!
10JAL#CALC!
11JAN#CALC!
12JAO#CALC!
13JAP#CALC!
14NIO#CALC!
15PLS#CALC!
16PLSL#CALC!
17PLSN#CALC!
18PO0#CALC!
19T1F0#CALC!
20AllTypes1234163132414216016116216316416516616716816916101611161216131614
21
Sheet1
Cell Formulas
RangeFormula
C2C2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
C3C3=LAMBDA(reference,[analysis_type],IF(IO(reference),NA(),LET(r,reference,a,PLS(PO0(analysis_type)),IF(OR(a={0,1,2,3}),LET(z,MAP(r,LAMBDA(b,IF(ISERROR(b),XERROR.TYPE(b),IF(b="",IF(ISBLANK(b),31,32),IF(ISNUMBER(b),1,IF(ISTEXT(b),2,IF(b,41,42))))))),SWITCH(a,0,SWITCH(z,1,"dt:NUMBER",2,"dt:TEXT",31,"dt:BLANK",32,"dt:BLANK",41,"dt:LOGICAL",42,"dt:LOGICAL","dt:ERROR"),1,SWITCH(z,1,"dt:NUMBER",2,"dt:TEXT",31,"dt:BLANK_REAL",32,"dt:BLANK_FORMULA",41,"dt:LOGICAL_TRUE",42,"dt:LOGICAL_FALSE",160,"dt:ERROR_EXTERNAL!",161,"dt:ERROR_NULL!",162,"dt:ERROR_DIV/0!",163,"dt:ERROR_VALUE!",164,"dt:ERROR_REF!",165,"dt:ERROR_NAME?",166,"dt:ERROR_NUM!",167,"dt:ERROR_N/A",168,"dt:ERROR_GETTING_Data",169,"dt:ERROR_SPILL!",1610,"dt:ERROR_CONNECT!",1611,"dt:ERROR_BLOCKED!",1612,"dt:ERROR_UNKNOWN!",1613,"dt:ERROR_FIELD!",1614,"dt:ERROR_CALC!"),2,SWITCH(z,1,1,2,2,31,3,32,3,41,4,42,4,16),3,z)),LET(t,MAP(r,LAMBDA(u,IF(OR(a={4,5}),TYPE(u),CELL("type",u)))),SWITCH(a,4,t,5,SWITCH(t,1,"dt:NUMBER",2,"dt:TEXT",4,"dt:LOGICAL",16,"dt:ERROR"),6,t))))))
C4C4=LAMBDA(reference,[analysis_type],[if_not_error],IF(IO(reference),NA(),LET(a,PLS(PO0(analysis_type)),o,SWITCH(a,0,SWITCH(ERROR.TYPE(reference),0,160,1,161,2,162,3,163,4,164,5,165,6,166,7,167,8,168,9,169,10,1610,11,1611,12,1612,13,1613,14,1614),1,SWITCH(ERROR.TYPE(reference),0,"dt:ERROR_EXTERNAL!",1,"dt:ERROR_NULL!",2,"dt:ERROR_DIV/0!",3,"dt:ERROR_VALUE!",4,"dt:ERROR_REF!",5,"dt:ERROR_NAME?",6,"dt:ERROR_NUM!",7,"dt:ERROR_N/A",8,"dt:ERROR_GETTING_Data",9,"dt:ERROR_SPILL!",10,"dt:ERROR_CONNECT!",11,"dt:ERROR_BLOCKED!",12,"dt:ERROR_UNKNOWN!",13,"dt:ERROR_FIELD!",14,"dt:ERROR_CALC!"),2,ERROR.TYPE(reference)),IF(ISERROR(a),o,IF(JAN(if_not_error),NA(),IF(IO(if_not_error),o,IF(ISERROR(o),if_not_error,o)))))))
C5C5=LAMBDA(parameter,ISOMITTED(parameter))
C6C6=LAMBDA(types,advanced_types_array,IF(SUM(T1F0(ISERROR(MATCH(types,AllTypes,0)))),NA(),LET(basic_types_array,SWITCH(advanced_types_array,1,1,2,2,31,3,32,3,41,4,42,4,"","",16),MAP(advanced_types_array,LAMBDA(a,OR(a=types)))+MAP(basic_types_array,LAMBDA(a,OR(a=types))))))
C7C7=LAMBDA(core_output,exclude_types,include_types,replace_with,main_array,advanced_types_array,LET(c,IF(IO(include_types),exclude_types,include_types),w,IF(ISNUMBER(core_output),1,0),x,JAB(c,advanced_types_array),m,IF(IO(include_types),IF(w*x,IF(IO(replace_with),"",replace_with),main_array),IF(w*x,main_array,IF(IO(replace_with),"",IF(w,replace_with,"")))),IF(IO(replace_with),JAH(core_output,x,m,include_types),m)))
C8C8=LAMBDA(core_cells,treated_cells,treated_output,include_types,LET(c,core_cells,t,treated_cells,m,IF(ISNUMBER(c),1,0),d,IF(IF(IO(include_types),t*m,t),1,0),i,IF(IO(include_types),m-d,d),e,(IF(BYROW(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(ROWS(c))),o,FILTER(e,e),f,(IF(BYCOL(i,LAMBDA(a,SUM(a))),1,0))*(SEQUENCE(,COLUMNS(c))),p,FILTER(f,f),CHOOSECOLS(CHOOSEROWS(treated_output,o),p)))
C9C9=LAMBDA(operation,if_empty,IF(JAN(if_empty),NA(),LET(e,IF(ISERROR(operation),IF(ERROR.TYPE(operation)=14,1,0),0),f,IF(ISERROR(ROWS(operation)*COLUMNS(operation)),1,0),IF(e+f=2,IF(IO(if_empty),operation,if_empty),operation))))
C10C10=LAMBDA(exclude_types,include_types,replace_with,IF(JAN(replace_with),NA(),IFS(AND(IO(exclude_types),IO(include_types),IO(replace_with)),0,OR(AND(IO(include_types),NIO(exclude_types)),AND(NIO(include_types),IO(exclude_types))),1)))
C11C11=LAMBDA([reference],LET(r,IFERROR(IF(reference="","",reference),""),IF(IO(reference),FALSE,IF(ROWS(r)*COLUMNS(r)>1,TRUE,FALSE))))
C12C12=LAMBDA(reference,IF(IO(reference),FALSE,IF(SUM(IF(ISERROR(reference),1,0)),TRUE,FALSE)))
C13C13=LAMBDA(reference,IF(IO(reference),NA(),IF(SUM(IF(IFERROR(reference,0)="",1,0)),TRUE,FALSE)))
C14C14=LAMBDA(parameter,NOT(ISOMITTED(parameter)))
C15C15=LAMBDA(parameter,INDEX(IF(OR(JAN(parameter),JAO(parameter),JAP(parameter)),NA(),parameter),1))
C16C16=LAMBDA([parameter],IF(IO(parameter),0,IF(JAN(parameter),NA(),LET(p,INDEX(parameter,1),IF(ISERROR(p),NA(),T1F0(p))))))
C17C17=LAMBDA(parameter,INDEX(IF(OR(JAN(parameter),JAO(parameter),JAP(parameter)),NA(),IF(ISNUMBER(parameter),IF(OR(MOD(parameter,1),parameter=0),NA(),parameter),NA())),1))
C18C18=LAMBDA([parameter],IF(IO(parameter),0,parameter))
C19C19=LAMBDA(expression,IF(ISNUMBER(expression)+ISLOGICAL(expression),IF(expression,1,0),NA()))
C20:Z20C20={1,2,3,4,16,31,32,41,42,160,161,162,163,164,165,166,167,168,169,1610,1611,1612,1613,1614}
Dynamic array formulas.
 
Demo #1 for "row size" and excluding types:

PROCESS.xlsx
ABCDEFGHIJKLMNOPQRST
1
2#CALC!
3
453bookTRUE32#DIV/0!a67
523.6778notebookTRUE0.543b
6#CALC! 17FALSE#REF!
7
8
9lengthcolumnsoutput_styleexclude_typesoutput
101omitted01bookTRUE#DIV/0!anotebookTRUEb#CALC!FALSE#REF!
111omitted11bookTRUE#DIV/0!anotebookTRUEb#CALC!FALSE#REF!
122omitted0253TRUE32#DIV/0!6723.6778TRUE
130.543#CALC!17FALSE#REF!
142omitted1253TRUE32#DIV/0!6723.6778
15TRUE0.543#CALC!17FALSE#REF!
163omitted0353bookTRUE32#DIV/0!a
176723.6778notebookTRUE0.543basic types
18b#CALC!17FALSE#REF!1dt:NUMBER
193omitted1353bookTRUE32#DIV/0!a672dt:TEXT
2023.6778notebookTRUE0.543b3dt:BLANK
21#CALC!17FALSE#REF!4dt:LOGICAL
224omitted0453book32#DIV/0!a16dt:ERROR
236723.6778notebook
240.543b#CALC!17advanced types
25#REF!1dt:NUMBER
264omitted1453book32#DIV/0!a2dt:TEXT
276723.6778notebook31dt:BLANK_REAL
280.543b#CALC!1732dt:BLANK_FORMULA
29#REF!41dt:LOGICAL_TRUE
305omitted01653bookTRUE3242dt:LOGICAL_FALSE
31a6723.6778160dt:ERROR_EXTERNAL!
32notebookTRUE0.543161dt:ERROR_NULL!
33b17FALSE162dt:ERROR_DIV/0!
34163dt:ERROR_VALUE!
355omitted11653bookTRUE32164dt:ERROR_REF!
36a6723.6778165dt:ERROR_NAME?
37notebookTRUE0.543b166dt:ERROR_NUM!
3817FALSE167dt:ERROR_N/A!
39168dt:ERROR_GETTING_DATA!
406omitted03153bookTRUE169dt:ERROR_SPILL!
4132#DIV/0!a1610dt:ERROR_CONNECT!
426723.67781611dt:ERROR_BLOCKED!
43notebookTRUE0.5431612dt:ERROR_UNKNOWN!
44b#CALC!1613dt:ERROR_FIELD!
4517FALSE#REF!1614dt:ERROR_CALC!
466omitted13153bookTRUE32
47#DIV/0!a6723.67
4878notebookTRUE
490.543b#CALC!
5017FALSE#REF!
517omitted03253bookTRUE
5232#DIV/0!a
536723.6778
54notebookTRUE
550.543b#CALC!
5617FALSE
57#REF!
587omitted13253bookTRUE
5932#DIV/0!a
606723.6778
61notebookTRUE
620.543b#CALC!
6317FALSE
64#REF!
658 or 9omitted04153book3253book32
66#DIV/0!a67#DIV/0!a67
6723.677823.6778
68notebook0.543bnotebook0.543b
69#CALC!17#CALC!17
70FALSE#REF!FALSE#REF!
71
728 or 9omitted14153book53book
7332#DIV/0!a32#DIV/0!a
746723.67786723.6778
75notebooknotebook
760.543b#CALC!0.543b#CALC!
7717FALSE17FALSE
78#REF!#REF!
7910omitted04153bookoutput_styleexclude_types
8032#DIV/0!14153book
81a6732#DIV/0!a
8223.67786723.6778
83notebooknotebook
840.543b0.543b#CALC!
85#CALC!17FALSE
8617FALSE#REF!
87#REF!
88output_styleexclude_types
8911 or 12 or 13 or 14 or 15 or 16 or 17 or 18 or 19omitted04253book53book53book14253book53book53book
90TRUE32TRUE32TRUE32TRUE32TRUE32TRUE32
91#DIV/0!a#DIV/0!a#DIV/0!a#DIV/0!a#DIV/0!a#DIV/0!a
926723.676723.676723.676723.676723.676723.67
93787878787878
94notebookTRUEnotebookTRUEnotebookTRUEnotebookTRUEnotebookTRUEnotebookTRUE
950.543b0.543b0.543b0.543b0.543b0.543b
96#CALC!#CALC!#CALC!#CALC!#CALC!#CALC!
97171717171717
98#REF!#REF!#REF!#REF!#REF!#REF!
99
10020omitted0425314253book
101bookTRUE32
102TRUE#DIV/0!a
103326723.67
104#DIV/0!78
105anotebookTRUE
106670.543b
10723.67#CALC!
1087817
109#REF!
110notebook
111TRUE
1120.543
113b
114#CALC!
115
11617
117
118#REF!
119output_styleexclude_types
12021 or greateromitted0162 or 164 or 16145353531162 or 164 or 1614535353
121bookbookbookbookbookbook
122TRUETRUETRUETRUETRUETRUE
123323232323232
124a#DIV/0!#DIV/0!a#DIV/0!#DIV/0!
12567aa67aa
12623.67676723.676767
1277823.6723.677823.6723.67
12878787878
129notebooknotebook
130TRUEnotebooknotebookTRUEnotebooknotebook
1310.543TRUETRUE0.543TRUETRUE
132b0.5430.543b0.5430.543
133#CALC!bb#CALC!bb
134#CALC!#CALC!
13517171717
136FALSE17FALSEFALSE17FALSE
137FALSEFALSE
138#REF!#REF!#REF!#REF!
139
140
res-r-ex-1
Cell Formulas
RangeFormula
B2B2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
F4F4=1/0
C6C6=IF(1,"")
F10:S10F10=PROCESS($B$4:$H$6,1,,0,1)
F11:S11F11=PROCESS($B$4:$H$6,1,,1,1)
F12:N13F12=PROCESS($B$4:$H$6,2,,0,2)
F14:O15F14=PROCESS($B$4:$H$6,2,,1,2)
F16:K18F16=PROCESS($B$4:$H$6,3,,0,3)
F19:L21F19=PROCESS($B$4:$H$6,3,,1,3)
F22:J25F22=PROCESS($B$4:$H$6,4,,0,4)
F26:K29F26=PROCESS($B$4:$H$6,4,,1,4)
F30:I34F30=PROCESS($B$4:$H$6,5,,0,16)
F35:J39F35=PROCESS($B$4:$H$6,5,,1,16)
F40:H45F40=PROCESS($B$4:$H$6,6,,0,31)
F46:I50F46=PROCESS($B$4:$H$6,6,,1,31)
F51:H57F51=PROCESS($B$4:$H$6,7,,0,32)
F58:H64F58=PROCESS($B$4:$H$6,7,,1,32)
F65:H71F65=PROCESS($B$4:$H$6,8,,0,41)
I65:K71I65=PROCESS($B$4:$H$6,9,,0,41)
F72:H78F72=PROCESS($B$4:$H$6,8,,1,41)
I72:K78I72=PROCESS($B$4:$H$6,9,,1,41)
F79:G88F79=PROCESS($B$4:$H$6,10,,0,41)
N80:P86N80=PROCESS($B$4:$H$6,10,,1,41)
F89:G98F89=PROCESS($B$4:$H$6,11,,0,42)
H89:I98H89=PROCESS($B$4:$H$6,15,,0,42)
J89:K98J89=PROCESS($B$4:$H$6,19,,0,42)
N89:O99N89=PROCESS($B$4:$H$6,11,,1,42)
P89:Q99P89=PROCESS($B$4:$H$6,15,,1,42)
R89:S99R89=PROCESS($B$4:$H$6,19,,1,42)
F100:F119F100=PROCESS($B$4:$H$6,20,,0,42)
N100:O110N100=PROCESS($B$4:$H$6,20,,1,42)
F120:F139F120=PROCESS($B$4:$H$6,21,,0,162)
G120:G139G120=PROCESS($B$4:$H$6,22,,0,164)
H120:H139H120=PROCESS($B$4:$H$6,30,,0,1614)
N120:N139N120=PROCESS($B$4:$H$6,21,,1,162)
O120:O139O120=PROCESS($B$4:$H$6,22,,1,164)
P120:P139P120=PROCESS($B$4:$H$6,30,,1,1614)
Dynamic array formulas.
 
Demo #2 for "row size" and excluding types (including if_empty):

PROCESS.xlsx
ABCDEFGHIJKLMNOPQRST
1
2#CALC!basic types
31dt:NUMBER
453bookTRUE32#DIV/0!a672dt:TEXT
523.6778notebookTRUE0.543b3dt:BLANK
6#CALC! 17FALSE#REF!4dt:LOGICAL
716dt:ERROR
8
9lengthcolumnsoutput_styleexclude_typesif_emptyoutputadvanced types
101omitted0{1,2}omittedTRUE#DIV/0!TRUE#CALC!FALSE#REF!1dt:NUMBER
111omitted1{1,2}omittedTRUE#DIV/0!TRUE#CALC!FALSE#REF!2dt:TEXT
122omitted0{1,3}omittedbookTRUE#DIV/0!anotebook31dt:BLANK_REAL
13TRUEb#CALC!FALSE#REF!32dt:BLANK_FORMULA
142omitted1{1,3}omitted bookTRUE#DIV/0!anotebook41dt:LOGICAL_TRUE
15TRUEb#CALC!FALSE#REF!42dt:LOGICAL_FALSE
163omitted0{1,4}omittedbook#DIV/0!a160dt:ERROR_EXTERNAL!
17notebookb#CALC!161dt:ERROR_NULL!
18#REF!162dt:ERROR_DIV/0!
193omitted1{1,4}omitted book#DIV/0!a163dt:ERROR_VALUE!
20notebookb164dt:ERROR_REF!
21#CALC!#REF!165dt:ERROR_NAME?
224omitted0{1,16}omittedbookTRUEa166dt:ERROR_NUM!
23notebookTRUE167dt:ERROR_N/A!
24bFALSE168dt:ERROR_GETTING_DATA!
25169dt:ERROR_SPILL!
264omitted1{1,16}omitted bookTRUEa1610dt:ERROR_CONNECT!
27notebookTRUE1611dt:ERROR_BLOCKED!
28bFALSE1612dt:ERROR_UNKNOWN!
291613dt:ERROR_FIELD!
305omitted0{1,31}omittedbookTRUE#DIV/0!1614dt:ERROR_CALC!
31anotebookTRUE
32b#CALC!
33FALSE#REF!
345omitted1{1,31}omitted bookTRUE#DIV/0!
35a
36notebookTRUEb#CALC!
37FALSE#REF!
386omitted0{1,32}omittedbookTRUE#DIV/0!
39anotebook
40TRUEb#CALC!
41FALSE#REF!
42
436omitted1{1,32}omitted bookTRUE
44#DIV/0!a
45notebookTRUE
46b#CALC!
47FALSE#REF!
48
497omitted0{1,41}omittedbook#DIV/0!
50a
51notebookb
52#CALC!
53FALSE
54#REF!
557omitted1{1,41}omitted book
56#DIV/0!a
57notebook
58b#CALC!
59FALSE
60#REF!
618 or 9 or 10omitted0{1,42}omittedbookTRUEbookTRUEbookTRUE
62#DIV/0!a#DIV/0!a#DIV/0!a
63notebooknotebooknotebook
64TRUEbTRUEbTRUEb
65#CALC!#CALC!#CALC!
66#REF!#REF!#REF!
67
688 or 9 or 10omitted1{1,42}omitted bookTRUE bookTRUE bookTRUE
69#DIV/0!a#DIV/0!a#DIV/0!a
70notebookTRUEnotebookTRUEnotebookTRUE
71b#CALC!b#CALC!b#CALC!
72
73#REF!#REF!#REF!
74output_styleexclude_typesif_empty
7511 or 12omitted0{2,3}omitted53TRUE53TRUE1{2,3}omitted5353
7632#DIV/0!32#DIV/0!TRUE32TRUE32
776723.676723.67#DIV/0!#DIV/0!
7878TRUE78TRUE6723.676723.67
790.543#CALC!0.543#CALC!7878
8017FALSE17FALSETRUETRUE
81#REF!#REF!0.5430.543
82#CALC!#CALC!
8317FALSE17FALSE
84#REF!#REF!
8513 or 14 or 15 or 16 or 17 or 18 or 19 or 20 or 21 or greateromitted0{2,3}omitted535353output_styleexclude_typesif_empty
86TRUETRUETRUE1{2,3}omitted535353
87323232TRUE32TRUE32TRUE32
88#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!#DIV/0!
896767676723.676723.676723.67
9023.6723.6723.67787878
91787878TRUETRUETRUE
92TRUETRUETRUE0.5430.5430.543
930.5430.5430.543#CALC!#CALC!#CALC!
94#CALC!#CALC!#CALC!17FALSE17FALSE17FALSE
95171717#REF!#REF!#REF!
96FALSEFALSEFALSE
97#REF!#REF!#REF!output_styleexclude_typesif_empty
9821 or greateromitted0{1,62} or {1,164} or {1,1614}omittedbookbookbook1{1,62} or {1,164} or {1,1614}omittedbookbookbook
99TRUETRUETRUETRUETRUETRUE
100a#DIV/0!#DIV/0!a#DIV/0!#DIV/0!
101aaaa
102notebooknotebook
103TRUEnotebooknotebookTRUEnotebooknotebook
104bTRUETRUEbTRUETRUE
105#CALC!bb#CALC!bb
106#CALC!#CALC!
107FALSEFALSEFALSEFALSE
108FALSEFALSE
109#REF!#REF!#REF!#REF!
110
1111omitted0{1,2,3,4,16}omitted#CALC!(empty)
1121omitted0{1,2,3,4,16}"empty"empty(empty)
1131omitted1{1,2,3,4,16}omitted#CALC!(empty)
1141omitted1{1,2,3,4,16}"empty"empty(empty)
1151omitted0{1,2,3,4,162,164}omitted#CALC!(not empty)
1161omitted0{1,2,3,4,162,164}"empty"#CALC!(not empty)
1171omitted1{1,2,3,4,162,164}omitted#CALC!(not empty)
1181omitted1{1,2,3,4,162,164}"empty"#CALC!(not empty)
119
res-r-ex-2
Cell Formulas
RangeFormula
B2B2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
F4F4=1/0
C6C6=IF(1,"")
G10:P10G10=PROCESS($B$4:$H$6,1,,0,{1,2})
G11:P11G11=PROCESS($B$4:$H$6,1,,1,{1,2})
G12:K13G12=PROCESS($B$4:$H$6,2,,0,{1,3})
G14:O15G14=PROCESS($B$4:$H$6,2,,1,{1,3})
G16:J18G16=PROCESS($B$4:$H$6,3,,0,{1,4})
G19:M21G19=PROCESS($B$4:$H$6,3,,1,{1,4})
G22:I25G22=PROCESS($B$4:$H$6,4,,0,{1,16})
G26:L29G26=PROCESS($B$4:$H$6,4,,1,{1,16})
G30:I33G30=PROCESS($B$4:$H$6,5,,0,{1,31})
G34:K37G34=PROCESS($B$4:$H$6,5,,1,{1,31})
G38:I42G38=PROCESS($B$4:$H$6,6,,0,{1,32})
G43:J48G43=PROCESS($B$4:$H$6,6,,1,{1,32})
G49:H54G49=PROCESS($B$4:$H$6,7,,0,{1,41})
G55:I60G55=PROCESS($B$4:$H$6,7,,1,{1,41})
G61:H67G61=PROCESS($B$4:$H$6,8,,0,{1,42})
J61:K67J61=PROCESS($B$4:$H$6,9,,0,{1,42})
M61:N67M61=PROCESS($B$4:$H$6,10,,0,{1,42})
G68:I73G68=PROCESS($B$4:$H$6,8,,1,{1,42})
J68:L73J68=PROCESS($B$4:$H$6,9,,1,{1,42})
M68:O73M68=PROCESS($B$4:$H$6,10,,1,{1,42})
G75:H81G75=PROCESS($B$4:$H$6,11,,0,{2,3})
I75:J81I75=PROCESS($B$4:$H$6,12,,0,{2,3})
O75:P84O75=PROCESS($B$4:$H$6,11,,1,{2,3})
Q75:R84,P86:Q95Q75=PROCESS($B$4:$H$6,15,,1,{2,3})
G85:G97G85=PROCESS($B$4:$H$6,13,,0,{2,3})
H85:H97H85=PROCESS($B$4:$H$6,15,,0,{2,3})
I85:I97I85=PROCESS($B$4:$H$6,21,,0,{2,3})
N86:O95N86=PROCESS($B$4:$H$6,13,,1,{2,3})
R86:S95R86=PROCESS($B$4:$H$6,20,,1,{2,3})
G98:G110G98=PROCESS($B$4:$H$6,21,,0,{1,162})
H98:H110H98=PROCESS($B$4:$H$6,22,,0,{1,164})
I98:I110I98=PROCESS($B$4:$H$6,30,,0,{1,1614})
N98:N110N98=PROCESS($B$4:$H$6,21,,1,{1,162})
O98:O110O98=PROCESS($B$4:$H$6,22,,1,{1,164})
P98:P110P98=PROCESS($B$4:$H$6,30,,1,{1,1614})
G111G111=PROCESS($B$4:$H$6,1,,0,{1,2,3,4,16})
G112G112=PROCESS($B$4:$H$6,1,,0,{1,2,3,4,16},,,"empty")
G113G113=PROCESS($B$4:$H$6,1,,1,{1,2,3,4,16})
G114G114=PROCESS($B$4:$H$6,1,,1,{1,2,3,4,16},,,"empty")
G115G115=PROCESS($B$4:$H$6,1,,0,{1,2,3,4,162,164})
G116G116=PROCESS($B$4:$H$6,1,,0,{1,2,3,4,162,164},,,"empty")
G117G117=PROCESS($B$4:$H$6,1,,1,{1,2,3,4,162,164})
G118G118=PROCESS($B$4:$H$6,1,,1,{1,2,3,4,162,164},,,"empty")
Dynamic array formulas.
 
Demo #3 for "column size" and excluding types:

PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1
253bookTRUE32#DIV/0!a67#CALC!
323.6778notebookTRUE0.543b
4#CALC! 17FALSE#REF!
5
6lengthcolumnsoutput_styleexclude_typesoutput
7output_styleexclude_types
81101book11book
9TRUETRUEbasic types
10#DIV/0!#DIV/0!1dt:NUMBER
11aa2dt:TEXT
123dt:BLANK
13notebooknotebook4dt:LOGICAL
14TRUETRUE16dt:ERROR
15bb
16#CALC!#CALC!advanced types
171dt:NUMBER
18FALSEFALSE2dt:TEXT
1931dt:BLANK_REAL
20#REF!#REF!32dt:BLANK_FORMULA
2141dt:LOGICAL_TRUE
22210253TRUE125342dt:LOGICAL_FALSE
2332#DIV/0!TRUE32160dt:ERROR_EXTERNAL!
246723.67#DIV/0!161dt:ERROR_NULL!
25786723.67162dt:ERROR_DIV/0!
26TRUE0.54378163dt:ERROR_VALUE!
27#CALC!TRUE164dt:ERROR_REF!
2817FALSE0.543165dt:ERROR_NAME?
29#REF!#CALC!166dt:ERROR_NUM!
3017FALSE167dt:ERROR_N/A!
31#REF!168dt:ERROR_GETTING_DATA!
32169dt:ERROR_SPILL!
33310353bookTRUE1353bookTRUE1610dt:ERROR_CONNECT!
3432#DIV/0!a32#DIV/0!a1611dt:ERROR_BLOCKED!
356723.67786723.67781612dt:ERROR_UNKNOWN!
36notebookTRUE0.543notebookTRUE1613dt:ERROR_FIELD!
37b#CALC!170.543b#CALC!1614dt:ERROR_CALC!
38FALSE#REF!17FALSE
39#REF!
40410453book32#DIV/0!1453book32
41a6723.6778#DIV/0!a6723.67
42notebook0.543b78notebook
43#CALC!170.543b#CALC!
44#REF!17#REF!
45
465101653bookTRUE32a11653bookTRUE32
476723.6778notebooka6723.6778
48TRUE0.543b17notebookTRUE0.543b
49FALSE17FALSE
50
516103153bookTRUE32#DIV/0!a13153bookTRUE32#DIV/0!a
526723.6778notebookTRUE0.5436723.6778notebookTRUE
53b#CALC!17FALSE#REF!0.543b#CALC!17FALSE
54#REF!
557103253bookTRUE32#DIV/0!a6713253bookTRUE32#DIV/0!a67
5623.6778notebookTRUE0.543b23.6778notebookTRUE0.543b
57#CALC!17FALSE#REF!#CALC!17FALSE#REF!
588104153book32#DIV/0!a6723.677814153book32#DIV/0!a6723.67
59notebook0.543b#CALC!17FALSE78notebook0.543b#CALC!
60#REF!17FALSE#REF!
619104253bookTRUE32#DIV/0!a6723.677814253bookTRUE32#DIV/0!a6723.6778
62notebookTRUE0.543b#CALC!17notebookTRUE0.543b#CALC!17
63#REF!#REF!
64101016253bookTRUE32a6723.6778notebook
65TRUE0.543b#CALC!17FALSE#REF!
66101116253bookTRUE32a6723.6778
67notebookTRUE0.543b#CALC!17FALSE#REF!
68
69111016453bookTRUE32#DIV/0!a6723.6778notebook
70TRUE0.543b#CALC!17FALSE
71111116453bookTRUE32#DIV/0!a6723.6778notebook
72TRUE0.543b#CALC!17FALSE
731210161453bookTRUE32#DIV/0!a6723.6778notebookTRUE
740.543b17FALSE#REF!
751211161453bookTRUE32#DIV/0!a6723.6778notebookTRUE
760.543b17FALSE#REF!
7713101bookTRUE#DIV/0!anotebookTRUEb#CALC!FALSE#REF!
78
7913111 bookTRUE#DIV/0!anotebookTRUE
80b#CALC!FALSE#REF!
811410253TRUE32#DIV/0!6723.6778TRUE0.543#CALC!17FALSE
82#REF!
831411253TRUE32#DIV/0!6723.6778TRUE0.543
84#CALC!17FALSE#REF!
851510353bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17
86FALSE#REF!
871511353bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!
8817FALSE#REF!
891610453book32#DIV/0!a6723.6778notebook0.543b#CALC!17
90#REF!
911611453book32#DIV/0!a6723.6778notebook0.543b#CALC!
9217#REF!
9317101653bookTRUE32a6723.6778notebookTRUE0.543b17FALSE
94
9517111653bookTRUE32a6723.6778notebookTRUE0.543b17
96FALSE
9718103153bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
9818113253bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE
99#REF!
10019103253bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
101
10219113253bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE
103#REF!
10420104153book32#DIV/0!a6723.6778notebook0.543b#CALC!17FALSE#REF!
10520114153book32#DIV/0!a6723.6778notebook0.543b#CALC!17FALSE#REF!
106
10721104253bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17#REF!
10821114253bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17#REF!
109221016253bookTRUE32a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
110221116253bookTRUE32a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
111301016453bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE
112301116453bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE
113
res-c-ex-1
Cell Formulas
RangeFormula
F2F2=1/0
J2J2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
C4C4=IF(1,"")
F8:F21F8=PROCESS($B$2:$H$4,1,1,0,1)
Q8:Q21Q8=PROCESS($B$2:$H$4,1,1,1,1)
F22:G30F22=PROCESS($B$2:$H$4,2,1,0,2)
Q22:R32Q22=PROCESS($B$2:$H$4,2,1,1,2)
F33:H38F33=PROCESS($B$2:$H$4,3,1,0,3)
Q33:S39Q33=PROCESS($B$2:$H$4,3,1,1,3)
F40:I44F40=PROCESS($B$2:$H$4,4,1,0,4)
Q40:T45Q40=PROCESS($B$2:$H$4,4,1,1,4)
F46:J49F46=PROCESS($B$2:$H$4,5,1,0,16)
Q46:U50Q46=PROCESS($B$2:$H$4,5,1,1,16)
F51:K53F51=PROCESS($B$2:$H$4,6,1,0,31)
Q51:V54Q51=PROCESS($B$2:$H$4,6,1,1,31)
F55:L57F55=PROCESS($B$2:$H$4,7,1,0,32)
Q55:W57Q55=PROCESS($B$2:$H$4,7,1,1,32)
F58:M60F58=PROCESS($B$2:$H$4,8,1,0,41)
Q58:X60Q58=PROCESS($B$2:$H$4,8,1,1,41)
F61:N63F61=PROCESS($B$2:$H$4,9,1,0,42)
Q61:Y63Q61=PROCESS($B$2:$H$4,9,1,1,42)
F64:O65F64=PROCESS($B$2:$H$4,10,1,0,162)
F66:O68F66=PROCESS($B$2:$H$4,10,1,1,162)
F69:P70F69=PROCESS($B$2:$H$4,11,1,0,164)
F71:P72F71=PROCESS($B$2:$H$4,11,1,1,164)
F73:Q74F73=PROCESS($B$2:$H$4,12,1,0,1614)
F75:Q76F75=PROCESS($B$2:$H$4,12,1,1,1614)
F77:R78F77=PROCESS($B$2:$H$4,13,1,0,1)
F79:O80F79=PROCESS($B$2:$H$4,13,1,1,1)
F81:S82F81=PROCESS($B$2:$H$4,14,1,0,2)
F83:Q84F83=PROCESS($B$2:$H$4,14,1,1,2)
F85:T86F85=PROCESS($B$2:$H$4,15,1,0,3)
F87:S88F87=PROCESS($B$2:$H$4,15,1,1,3)
F89:U90F89=PROCESS($B$2:$H$4,16,1,0,4)
F91:T92F91=PROCESS($B$2:$H$4,16,1,1,4)
F93:V94F93=PROCESS($B$2:$H$4,17,1,0,16)
F95:T96F95=PROCESS($B$2:$H$4,17,1,1,16)
F97:W97F97=PROCESS($B$2:$H$4,18,1,0,31)
F98:V99F98=PROCESS($B$2:$H$4,18,1,1,31)
F100:X101F100=PROCESS($B$2:$H$4,19,1,0,32)
F102:W103F102=PROCESS($B$2:$H$4,19,1,1,32)
F104:X104F104=PROCESS($B$2:$H$4,20,1,0,41)
F105:W106F105=PROCESS($B$2:$H$4,20,1,1,41)
F107:Y107F107=PROCESS($B$2:$H$4,21,1,0,42)
F108:Y108F108=PROCESS($B$2:$H$4,21,1,1,42)
F109:Y109F109=PROCESS($B$2:$H$4,22,1,0,162)
F110:Y110F110=PROCESS($B$2:$H$4,22,1,1,162)
F111:Y111F111=PROCESS($B$2:$H$4,30,1,0,164)
F112:Y112F112=PROCESS($B$2:$H$4,30,1,1,164)
Dynamic array formulas.
 
Demo #4 for "column size" and excluding types:

PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVWX
1
253bookTRUE32#DIV/0!a67#CALC!
323.6778notebookTRUE0.543b
4#CALC! 17FALSE#REF!
5
6lengthcolumnsoutput_styleexclude_typesoutput
7output_styleexclude_types
8110{1,2}TRUE1{1,2}TRUEbasic types
9#DIV/0!#DIV/0!1dt:NUMBER
102dt:TEXT
11TRUETRUE3dt:BLANK
12#CALC!#CALC!4dt:LOGICAL
1316dt:ERROR
14FALSEFALSE
15advanced types
16#REF!#REF!1dt:NUMBER
172dt:TEXT
18210{1,3}bookTRUE1{1,3} book31dt:BLANK_REAL
19#DIV/0!aTRUE32dt:BLANK_FORMULA
20notebookTRUE#DIV/0!a41dt:LOGICAL_TRUE
21b#CALC!notebookTRUE42dt:LOGICAL_FALSE
22FALSE#REF!b160dt:ERROR_EXTERNAL!
23#CALC!161dt:ERROR_NULL!
24FALSE162dt:ERROR_DIV/0!
25#REF!163dt:ERROR_VALUE!
26310{1,4}book#DIV/0!a1{1,4} book164dt:ERROR_REF!
27notebookb#DIV/0!a165dt:ERROR_NAME?
28#CALC!notebook166dt:ERROR_NUM!
29#REF!b#CALC!167dt:ERROR_N/A!
30168dt:ERROR_GETTING_DATA!
31#REF!169dt:ERROR_SPILL!
32410{1,16}bookTRUEa1{1,16} bookTRUE1610dt:ERROR_CONNECT!
33notebookTRUEba1611dt:ERROR_BLOCKED!
34FALSEnotebookTRUE1612dt:ERROR_UNKNOWN!
35b1613dt:ERROR_FIELD!
36FALSE1614dt:ERROR_CALC!
37
38510{1,31}bookTRUE#DIV/0!anotebook1{1,31} bookTRUE#DIV/0!
39TRUEb#CALC!FALSEa
40#REF!notebookTRUEb#CALC!
41FALSE#REF!
42610{1,32}bookTRUE#DIV/0!anotebook1{1,32} bookTRUE#DIV/0!a
43TRUEb#CALC!FALSE#REF!notebookTRUE
44b#CALC!FALSE
45#REF!
46710{1,41}book#DIV/0!anotebookb#CALC!1{1,41} book#DIV/0!a
47FALSE#REF!notebookb
48#CALC!FALSE#REF!
49810{1,42}bookTRUE#DIV/0!anotebookTRUEb1{1,42}bookTRUE#DIV/0!a
50#CALC!#REF!notebookTRUEb#CALC!
51#REF!
52910{1,162}bookTRUEanotebookTRUEb#CALC!1{1,162} bookTRUEa
53FALSE#REF!notebookTRUEb#CALC!FALSE
54#REF!
551010{1,164}bookTRUE#DIV/0!anotebookTRUEb#CALC!
56FALSE
571011{1,164} bookTRUE#DIV/0!a
58notebookTRUEb#CALC!FALSE
59
601110{1,1614}bookTRUE#DIV/0!anotebookTRUEbFALSE
61#REF!
621111{1,1614} bookTRUE#DIV/0!anotebook
63TRUEbFALSE#REF!
641210{2,3}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!17FALSE
65#REF!
661211{2,3}53TRUE32#DIV/0!6723.6778TRUE
670.543#CALC!17FALSE#REF!
681310{2,4}5332#DIV/0!6723.67780.543#CALC!17#REF!
69
701311{2,4}5332#DIV/0!6723.67780.543
71#CALC!17#REF!
721410{2,16}53TRUE326723.6778TRUE0.54317FALSE
731411{2,16}53TRUE326723.6778TRUE0.543
7417FALSE
751510{2,31}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!17FALSE#REF!
761511{2,31}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!
7717FALSE#REF!
781610{2,32}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!17FALSE#REF!
791611{2,32}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!
8017FALSE#REF!
811710{2,41}5332#DIV/0!6723.67780.543#CALC!17FALSE#REF!
821711{2,41}5332#DIV/0!6723.67780.543#CALC!17
83FALSE#REF!
841810{2,162}53TRUE326723.6778TRUE0.543#CALC!17FALSE#REF!
851811{2,162}53TRUE326723.6778TRUE0.543#CALC!17FALSE
86#REF!
871910{2,164}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!17FALSE
881911{2,164}53TRUE32#DIV/0!6723.6778TRUE0.543#CALC!17FALSE
89
902010{2,1614}53TRUE32#DIV/0!6723.6778TRUE0.54317FALSE#REF!
912011{2,1614}53TRUE32#DIV/0!6723.6778TRUE0.54317FALSE#REF!
92
932110{3,4}53book32#DIV/0!a6723.6778notebook0.543b#CALC!17#REF!
942111{3,4}53book32#DIV/0!a6723.6778notebook0.543b#CALC!17#REF!
952210{3,16}53bookTRUE32a6723.6778notebookTRUE0.543b17FALSE
962211{3,16}53bookTRUE32a6723.6778notebookTRUE0.543b17FALSE
973010{3,31}53bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
983011{3,31}53bookTRUE32#DIV/0!a6723.6778notebookTRUE0.543b#CALC!17FALSE#REF!
99
res-c-ex-2
Cell Formulas
RangeFormula
F2F2=1/0
J2J2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
C4C4=IF(1,"")
F8:F17F8=PROCESS($B$2:$H$4,1,1,0,{1,2})
Q8:Q17Q8=PROCESS($B$2:$H$4,1,1,1,{1,2})
F18:G22F18=PROCESS($B$2:$H$4,2,1,0,{1,3})
Q18:R25Q18=PROCESS($B$2:$H$4,2,1,1,{1,3})
F26:H29F26=PROCESS($B$2:$H$4,3,1,0,{1,4})
Q26:S31Q26=PROCESS($B$2:$H$4,3,1,1,{1,4})
F32:I34F32=PROCESS($B$2:$H$4,4,1,0,{1,16})
Q32:T37Q32=PROCESS($B$2:$H$4,4,1,1,{1,16})
F38:J40F38=PROCESS($B$2:$H$4,5,1,0,{1,31})
Q38:U41Q38=PROCESS($B$2:$H$4,5,1,1,{1,31})
F42:K44F42=PROCESS($B$2:$H$4,6,1,0,{1,32})
Q42:V45Q42=PROCESS($B$2:$H$4,6,1,1,{1,32})
F46:L47F46=PROCESS($B$2:$H$4,7,1,0,{1,41})
Q46:W48Q46=PROCESS($B$2:$H$4,7,1,1,{1,41})
F49:M50F49=PROCESS($B$2:$H$4,8,1,0,{1,42})
Q49:W51Q49=PROCESS($B$2:$H$4,8,1,1,{1,42})
F52:N53F52=PROCESS($B$2:$H$4,9,1,0,{1,162})
Q52:W54Q52=PROCESS($B$2:$H$4,9,1,1,{1,162})
F55:O56F55=PROCESS($B$2:$H$4,10,1,0,{1,164})
F57:N59F57=PROCESS($B$2:$H$4,10,1,1,{1,164})
F60:P61F60=PROCESS($B$2:$H$4,11,1,0,{1,1614})
F62:O63F62=PROCESS($B$2:$H$4,11,1,1,{1,1614})
F64:Q65F64=PROCESS($B$2:$H$4,12,1,0,{2,3})
F66:N67F66=PROCESS($B$2:$H$4,12,1,1,{2,3})
F68:R69F68=PROCESS($B$2:$H$4,13,1,0,{2,4})
F70:P71F70=PROCESS($B$2:$H$4,13,1,1,{2,4})
F72:S72F72=PROCESS($B$2:$H$4,14,1,0,{2,16})
F73:P74F73=PROCESS($B$2:$H$4,14,1,1,{2,16})
F75:S75F75=PROCESS($B$2:$H$4,15,1,0,{2,31})
F76:P77F76=PROCESS($B$2:$H$4,15,1,1,{2,31})
F78:U78F78=PROCESS($B$2:$H$4,16,1,0,{2,32})
F79:Q80F79=PROCESS($B$2:$H$4,16,1,1,{2,32})
F81:T81F81=PROCESS($B$2:$H$4,17,1,0,{2,41})
F82:R83F82=PROCESS($B$2:$H$4,17,1,1,{2,41})
F84:U84F84=PROCESS($B$2:$H$4,18,1,0,{2,162})
F85:S86F85=PROCESS($B$2:$H$4,18,1,1,{2,162})
F87:U87F87=PROCESS($B$2:$H$4,19,1,0,{2,164})
F88:U89F88=PROCESS($B$2:$H$4,19,1,1,{2,164})
F90:U90F90=PROCESS($B$2:$H$4,20,1,0,{2,1614})
F91:T92F91=PROCESS($B$2:$H$4,20,1,1,{2,1614})
F93:S93F93=PROCESS($B$2:$H$4,21,1,0,{3,4})
F94:S94F94=PROCESS($B$2:$H$4,21,1,1,{3,4})
F95:S95F95=PROCESS($B$2:$H$4,22,1,0,{3,16})
F96:S96F96=PROCESS($B$2:$H$4,22,1,1,{3,16})
F97:V97F97=PROCESS($B$2:$H$4,30,1,0,{3,31})
F98:V98F98=PROCESS($B$2:$H$4,30,1,1,{3,31})
Dynamic array formulas.
 
Demos #5 and #6 for "row size" and including types:

PROCESS.xlsx
ABCDEFGHIJKLMN
1
2#CALC!
3
453bookTRUE32#DIV/0!a67
523.6778notebookTRUE0.543b
6#CALC! 17FALSE#REF!
7
8
9lengthcolumnsoutput_styleinclude_typesoutput
101omitted0153326723.67780.54317
111omitted1153326723.67780.54317
122omitted02booka
13notebookb
142omitted12bookanotebookbasic types
15b1dt:NUMBER
163omitted03 2dt:TEXT
173dt:BLANK
183omitted13 4dt:LOGICAL
1916dt:ERROR
204omitted04TRUE
21TRUEadvanced types
22FALSE1dt:NUMBER
234omitted14TRUE2dt:TEXT
24TRUE31dt:BLANK_REAL
25FALSE32dt:BLANK_FORMULA
265omitted016#DIV/0!41dt:LOGICAL_TRUE
27#CALC!42dt:LOGICAL_FALSE
28#REF!160dt:ERROR_EXTERNAL!
295omitted116#DIV/0!161dt:ERROR_NULL!
30#CALC!162dt:ERROR_DIV/0!
31#REF!163dt:ERROR_VALUE!
326omitted031 164dt:ERROR_REF!
33165dt:ERROR_NAME?
34166dt:ERROR_NUM!
356omitted131 167dt:ERROR_N/A!
36168dt:ERROR_GETTING_DATA!
37169dt:ERROR_SPILL!
387omitted032 1610dt:ERROR_CONNECT!
397omitted132 1611dt:ERROR_BLOCKED!
408omitted041TRUE1612dt:ERROR_UNKNOWN!
41TRUE1613dt:ERROR_FIELD!
428omitted141TRUE1614dt:ERROR_CALC!
43TRUE
449omitted042FALSE
459omitted142FALSE
4610omitted0153
4732
4867
4923.67
5078
510.543
5217
5310omitted1153
5432
556723.6778
560.543
5717
5811 or 12 or 13 or 14 or 15 or 16 or 17 or 18 or 19 or 20omitted02bookbookbook
59aaa
60notebooknotebooknotebook
61bbb
6211 or 12 or 13 or 14 or 15 or 16 or 17 or 18 or 19 or 20omitted12 book book book
63aaa
64notebooknotebooknotebook
65bbb
6621 or greateromitted0162 or 164 or 1614#DIV/0!#REF!#CALC!
6721 or greateromitted1162 or 164 or 1614#DIV/0!#REF!#CALC!
68
res-r-in-1
Cell Formulas
RangeFormula
B2B2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
F4F4=1/0
C6C6=IF(1,"")
F10:L10F10=PROCESS($B$4:$H$6,1,,0,,1)
F11:L11F11=PROCESS($B$4:$H$6,1,,1,,1)
F12:G13F12=PROCESS($B$4:$H$6,2,,0,,2)
F14:I15F14=PROCESS($B$4:$H$6,2,,1,,2)
F16:G17F16=PROCESS($B$4:$H$6,3,,0,,3)
F18:I19F18=PROCESS($B$4:$H$6,3,,1,,3)
F20:F22F20=PROCESS($B$4:$H$6,4,,0,,4)
F23:G25F23=PROCESS($B$4:$H$6,4,,1,,4)
F26:F28F26=PROCESS($B$4:$H$6,5,,0,,16)
F29:F31F29=PROCESS($B$4:$H$6,5,,1,,16)
F32:F34F32=PROCESS($B$4:$H$6,6,,0,,31)
F35:H37F35=PROCESS($B$4:$H$6,6,,1,,31)
F38F38=PROCESS($B$4:$H$6,7,,0,,32)
F39F39=PROCESS($B$4:$H$6,7,,1,,32)
F40:F41F40=PROCESS($B$4:$H$6,8,,0,,41)
F42:F43F42=PROCESS($B$4:$H$6,8,,1,,41)
F44F44=PROCESS($B$4:$H$6,9,,0,,42)
F45F45=PROCESS($B$4:$H$6,9,,1,,42)
F46:F52F46=PROCESS($B$4:$H$6,10,,0,,1)
F53:H57F53=PROCESS($B$4:$H$6,10,,1,,1)
F58:F61F58=PROCESS($B$4:$H$6,11,,0,,2)
I58:I61I58=PROCESS($B$4:$H$6,15,,0,,2)
L58:L61L58=PROCESS($B$4:$H$6,20,,0,,2)
F62:G65F62=PROCESS($B$4:$H$6,11,,1,,2)
I62:J65I62=PROCESS($B$4:$H$6,15,,1,,2)
L62:M65L62=PROCESS($B$4:$H$6,20,,1,,2)
F66F66=PROCESS($B$4:$H$6,21,,0,,162)
G66G66=PROCESS($B$4:$H$6,22,,0,,164)
H66H66=PROCESS($B$4:$H$6,30,,0,,1614)
F67F67=PROCESS($B$4:$H$6,21,,1,,162)
G67G67=PROCESS($B$4:$H$6,22,,1,,164)
H67H67=PROCESS($B$4:$H$6,30,,1,,1614)
Dynamic array formulas.




PROCESS.xlsx
ABCDEFGHIJKLMNOPQ
1
2#CALC!
3
453bookTRUE32#DIV/0!a67
523.6778notebookTRUE0.543b
6#CALC! 17FALSE#REF!
7
8
9lengthcolumnsoutput_styleexclude_typesoutput
101omitted0{1,2}53book32a6723.6778notebook0.543b17
111omitted1{1,2}53book32a6723.6778notebook0.543b17
122omitted0{1,3}53326723.6778
130.54317
142omitted1{1,3}53326723.6778
150.54317
163omitted0{1,4}53TRUE3267
1723.6778TRUE0.543basic types
1817FALSE1dt:NUMBER
193omitted1{1,4}53TRUE32672dt:TEXT
2023.6778TRUE0.5433dt:BLANK
2117FALSE4dt:LOGICAL
224omitted0{1,16}5332#DIV/0!16dt:ERROR
236723.6778
240.543#CALC!17advanced types
25#REF!1dt:NUMBER
264omitted1{1,16}5332#DIV/0!2dt:TEXT
276723.677831dt:BLANK_REAL
280.543#CALC!1732dt:BLANK_FORMULA
29#REF!41dt:LOGICAL_TRUE
305omitted0{1,31}533242dt:LOGICAL_FALSE
316723.67160dt:ERROR_EXTERNAL!
3278161dt:ERROR_NULL!
330.54317162dt:ERROR_DIV/0!
34163dt:ERROR_VALUE!
355omitted1{1,31}5332164dt:ERROR_REF!
366723.6778165dt:ERROR_NAME?
370.543166dt:ERROR_NUM!
3817167dt:ERROR_N/A!
39168dt:ERROR_GETTING_DATA!
406omitted0{1,32}5332169dt:ERROR_SPILL!
416723.671610dt:ERROR_CONNECT!
42780.5431611dt:ERROR_BLOCKED!
43171612dt:ERROR_UNKNOWN!
446omitted1{1,32}53321613dt:ERROR_FIELD!
456723.671614dt:ERROR_CALC!
4678
470.543
4817
497omitted0{1,41}53TRUE
503267
5123.6778
52TRUE0.543
5317
547omitted1{1,41}53TRUE
5532
566723.6778
57TRUE
580.543
5917
608 or 9 or 10omitted0{1,42}535353
61323232
62676767
6323.6723.6723.67
64787878
650.5430.5430.543
66171717
67FALSEFALSEFALSE
688 or 9 or 10omitted1{1,42}535353
69323232
706723.67786723.67786723.6778
710.5430.5430.543
7217FALSE17FALSE17FALSE
7311 or 12 or 13 or 14 or 15 or 16 or 17 or 18 or 19 or 20omitted0{2,3}bookbookbook
74aaa
75
76notebooknotebooknotebook
77bbb
78
79
80
8111 or 12 or 13 or 14 or 15 or 16 or 17 or 18 or 19 or 20omitted1{2,3} book book book
82aaa
83
84notebooknotebooknotebook
85bbb
86
87
88
8921 or greateromitted0{1,62} or {1,164} or {1,1614}535353
90323232
91#DIV/0!6767
926723.6723.67
9323.677878
94780.5430.543
950.54317#CALC!
9617#REF!17
9721 or greateromitted1{1,62} or {1,164} or {1,1614}535353
98323232
99#DIV/0!6767
1006723.6723.67
10123.677878
102780.5430.543
1030.54317#CALC!
10417#REF!17
105
res-r-in-2
Cell Formulas
RangeFormula
B2B2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
F4F4=1/0
C6C6=IF(1,"")
F10:P10F10=PROCESS($B$4:$H$6,1,,0,,{1,2})
F11:P11F11=PROCESS($B$4:$H$6,1,,1,,{1,2})
F12:K13F12=PROCESS($B$4:$H$6,2,,0,,{1,3})
F14:N15F14=PROCESS($B$4:$H$6,2,,1,,{1,3})
F16:I18F16=PROCESS($B$4:$H$6,3,,0,,{1,4})
F19:L21F19=PROCESS($B$4:$H$6,3,,1,,{1,4})
F22:H25F22=PROCESS($B$4:$H$6,4,,0,,{1,16})
F26:J29F26=PROCESS($B$4:$H$6,4,,1,,{1,16})
F30:G34F30=PROCESS($B$4:$H$6,5,,0,,{1,31})
F35:J39F35=PROCESS($B$4:$H$6,5,,1,,{1,31})
F40:G43F40=PROCESS($B$4:$H$6,6,,0,,{1,32})
F44:H48F44=PROCESS($B$4:$H$6,6,,1,,{1,32})
F49:G53F49=PROCESS($B$4:$H$6,7,,0,,{1,41})
F54:H59F54=PROCESS($B$4:$H$6,7,,1,,{1,41})
F60:F67F60=PROCESS($B$4:$H$6,8,,0,,{1,42})
I60:I67I60=PROCESS($B$4:$H$6,9,,0,,{1,42})
L60:L67L60=PROCESS($B$4:$H$6,10,,0,,{1,42})
F68:H72F68=PROCESS($B$4:$H$6,8,,1,,{1,42})
I68:K72I68=PROCESS($B$4:$H$6,9,,1,,{1,42})
L68:N72L68=PROCESS($B$4:$H$6,10,,1,,{1,42})
F73:F80F73=PROCESS($B$4:$H$6,11,,0,,{2,3})
H73:H80H73=PROCESS($B$4:$H$6,15,,0,,{2,3})
J73:J80J73=PROCESS($B$4:$H$6,20,,0,,{2,3})
F81:G88F81=PROCESS($B$4:$H$6,11,,1,,{2,3})
H81:I88H81=PROCESS($B$4:$H$6,15,,1,,{2,3})
J81:K88J81=PROCESS($B$4:$H$6,20,,1,,{2,3})
F89:F96F89=PROCESS($B$4:$H$6,21,,0,,{1,162})
G89:G96G89=PROCESS($B$4:$H$6,22,,0,,{1,164})
H89:H96H89=PROCESS($B$4:$H$6,30,,0,,{1,1614})
F97:F104F97=PROCESS($B$4:$H$6,21,,1,,{1,162})
G97:G104G97=PROCESS($B$4:$H$6,22,,1,,{1,164})
H97:H104H97=PROCESS($B$4:$H$6,30,,1,,{1,1614})
Dynamic array formulas.
 
Demos #7 and #8 for "column size" and including types:

PROCESS.xlsx
ABCDEFGHIJKLMNOPQRST
1
253bookTRUE32#DIV/0!a67#CALC!
323.6778notebookTRUE0.543b
4#CALC! 17FALSE#REF!
5
6lengthcolumnsoutput_styleexclude_typesoutput
7output_styleexclude_types
81101531153
93232
106767
1123.6723.67
127878
130.5430.543
141717
152102booka12 book
16notebookba
17notebook
18b
193103 13 
20
21
224104TRUETRUEFALSE14 TRUE
23TRUE
24FALSE
2551016#DIV/0!#CALC!#REF!116#DIV/0!
26#CALC!
27#REF!
2861031 131 
29
3071032 132 
3181041TRUETRUE141TRUE
32TRUE
3391042FALSE142FALSE
341010162#DIV/0!
351011162#DIV/0!
361110164#REF!basic types
371111164#REF!1dt:NUMBER
3812101614#CALC!2dt:TEXT
3912111614#CALC!3dt:BLANK
401310153326723.67780.543174dt:LOGICAL
411311153326723.67780.54316dt:ERROR
4217
4314102bookanotebookbadvanced types
4414112bookanotebookb1dt:NUMBER
4515103 2dt:TEXT
4615113 31dt:BLANK_REAL
4732dt:BLANK_FORMULA
4816104TRUETRUEFALSE41dt:LOGICAL_TRUE
4916114 TRUETRUE42dt:LOGICAL_FALSE
50FALSE160dt:ERROR_EXTERNAL!
51171016#DIV/0!#CALC!#REF!161dt:ERROR_NULL!
52171116 #DIV/0!#CALC!162dt:ERROR_DIV/0!
53#REF!163dt:ERROR_VALUE!
54181031 164dt:ERROR_REF!
55181131 165dt:ERROR_NAME?
56166dt:ERROR_NUM!
57191032 167dt:ERROR_N/A!
58191132 168dt:ERROR_GETTING_DATA!
59201041TRUETRUE169dt:ERROR_SPILL!
60201141TRUETRUE1610dt:ERROR_CONNECT!
61211042FALSE1611dt:ERROR_BLOCKED!
62211142FALSE1612dt:ERROR_UNKNOWN!
632210162#DIV/0!1613dt:ERROR_FIELD!
642211162#DIV/0!1614dt:ERROR_CALC!
653010164#REF!
663011164#REF!
67
res-c-in-1
Cell Formulas
RangeFormula
F2F2=1/0
J2J2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
C4C4=IF(1,"")
F8:F14F8=PROCESS($B$2:$H$4,1,1,0,,1)
Q8:Q14Q8=PROCESS($B$2:$H$4,1,1,1,,1)
F15:G16F15=PROCESS($B$2:$H$4,2,1,0,,2)
Q15:R18Q15=PROCESS($B$2:$H$4,2,1,1,,2)
F19:H20F19=PROCESS($B$2:$H$4,3,1,0,,3)
Q19:R21Q19=PROCESS($B$2:$H$4,3,1,1,,3)
F22:H22F22=PROCESS($B$2:$H$4,4,1,0,,4)
Q22:S24Q22=PROCESS($B$2:$H$4,4,1,1,,4)
F25:H25F25=PROCESS($B$2:$H$4,5,1,0,,16)
Q25:Q27Q25=PROCESS($B$2:$H$4,5,1,1,,16)
F28:H28F28=PROCESS($B$2:$H$4,6,1,0,,31)
Q28:S29Q28=PROCESS($B$2:$H$4,6,1,1,,31)
F30F30=PROCESS($B$2:$H$4,7,1,0,,32)
F31:G31F31=PROCESS($B$2:$H$4,8,1,0,,41)
Q30Q30=PROCESS($B$2:$H$4,7,1,1,,32)
Q31:R32Q31=PROCESS($B$2:$H$4,8,1,1,,41)
Q33Q33=PROCESS($B$2:$H$4,9,1,1,,42)
F33F33=PROCESS($B$2:$H$4,9,1,0,,42)
F34F34=PROCESS($B$2:$H$4,10,1,0,,162)
F35F35=PROCESS($B$2:$H$4,10,1,1,,162)
F36F36=PROCESS($B$2:$H$4,11,1,0,,164)
F37F37=PROCESS($B$2:$H$4,11,1,1,,164)
F38F38=PROCESS($B$2:$H$4,12,1,0,,1614)
F39F39=PROCESS($B$2:$H$4,12,1,1,,1614)
F40:L40F40=PROCESS($B$2:$H$4,13,1,0,,1)
F41:K42F41=PROCESS($B$2:$H$4,13,1,1,,1)
F43:I43F43=PROCESS($B$2:$H$4,14,1,0,,2)
F44:I44F44=PROCESS($B$2:$H$4,14,1,1,,2)
F45:I45F45=PROCESS($B$2:$H$4,15,1,0,,3)
F46:I47F46=PROCESS($B$2:$H$4,15,1,1,,3)
F48:H48F48=PROCESS($B$2:$H$4,16,1,0,,4)
F49:H50F49=PROCESS($B$2:$H$4,16,1,1,,4)
F51:H51F51=PROCESS($B$2:$H$4,17,1,0,,16)
F52:H53F52=PROCESS($B$2:$H$4,17,1,1,,16)
F54:H54F54=PROCESS($B$2:$H$4,18,1,0,,31)
F55:H56F55=PROCESS($B$2:$H$4,18,1,1,,31)
F57F57=PROCESS($B$2:$H$4,19,1,0,,32)
F58F58=PROCESS($B$2:$H$4,19,1,1,,32)
F59:G59F59=PROCESS($B$2:$H$4,20,1,0,,41)
F60:G60F60=PROCESS($B$2:$H$4,20,1,1,,41)
F61F61=PROCESS($B$2:$H$4,21,1,0,,42)
F62F62=PROCESS($B$2:$H$4,21,1,1,,42)
F63F63=PROCESS($B$2:$H$4,22,1,0,,162)
F64F64=PROCESS($B$2:$H$4,22,1,1,,162)
F65F65=PROCESS($B$2:$H$4,30,1,0,,164)
F66F66=PROCESS($B$2:$H$4,30,1,1,,164)
Dynamic array formulas.




PROCESS.xlsx
ABCDEFGHIJKLMNOPQRSTUVW
1
253bookTRUE32#DIV/0!a67#CALC!
323.6778notebookTRUE0.543b
4#CALC! 17FALSE#REF!
5
6lengthcolumnsoutput_styleexclude_typesoutput
7output_styleexclude_types
8110{1,2}531{1,2}53
9bookbookbasic types
1032321dt:NUMBER
11aa2dt:TEXT
1267673dt:BLANK
1323.6723.674dt:LOGICAL
14787816dt:ERROR
15notebooknotebook
160.5430.543advanced types
17bb1dt:NUMBER
1817172dt:TEXT
19210{1,3}53321{1,3}5331dt:BLANK_REAL
206723.673232dt:BLANK_FORMULA
21786723.6741dt:LOGICAL_TRUE
220.5437842dt:LOGICAL_FALSE
23170.543160dt:ERROR_EXTERNAL!
24161dt:ERROR_NULL!
2517162dt:ERROR_DIV/0!
26163dt:ERROR_VALUE!
27164dt:ERROR_REF!
28310{1,4}53TRUE321{1,4}53TRUE165dt:ERROR_NAME?
296723.677832166dt:ERROR_NUM!
30TRUE0.543176723.6778167dt:ERROR_N/A!
31FALSETRUE168dt:ERROR_GETTING_DATA!
320.543169dt:ERROR_SPILL!
3317FALSE1610dt:ERROR_CONNECT!
34410{1,16}5332#DIV/0!671{1,16}53321611dt:ERROR_BLOCKED!
3523.67780.543#CALC!#DIV/0!6723.671612dt:ERROR_UNKNOWN!
3617#REF!781613dt:ERROR_FIELD!
370.543#CALC!1614dt:ERROR_CALC!
3817#REF!
39510{1,31}53326723.67781{1,31}5332
400.543176723.6778
410.543
4217
43
44610{1,32}53326723.67780.5431{1,32}5332
45176723.6778
460.54317
47710{1,41}53TRUE326723.6778TRUE1{1,41}53TRUE3267
480.5431723.6778TRUE0.543
4917
50810{1,42}53326723.67780.54317FALSE1{1,42}53326723.67
51780.543
5217FALSE
53910{1,162}5332#DIV/0!6723.67780.543171{1,162}5332#DIV/0!6723.6778
540.54317
551010{1,164}53326723.67780.54317#REF!
561011{1,164}53326723.6778
570.54317#REF!
581110{1,1614}53326723.67780.543#CALC!17
591111{1,1614}53326723.6778
600.543#CALC!17
611210{2,3}bookanotebookb
621211{2,3}bookanotebook
63b
641310{2,4}bookTRUEanotebookTRUEbFALSE
651311{2,4} bookTRUEanotebookTRUE
66bFALSE
671410{2,16}book#DIV/0!anotebookb#CALC!#REF!
681411{2,16} book#DIV/0!anotebookb
69#CALC!#REF!
701510{2,31}bookanotebookb
711511{2,31}bookanotebookb
72
731610{2,32}bookanotebookb
741611{2,32}bookanotebookb
751710{2,41}bookTRUEanotebookTRUEb
761711{2,41}bookTRUEanotebookTRUEb
771810{2,162}book#DIV/0!anotebookb
781811{2,162}book#DIV/0!anotebookb
791910{2,164}bookanotebookb#REF!
801911{2,164} bookanotebookb
81#REF!
822010{2,1614}bookanotebookb#CALC!
832011{2,1614}bookanotebookb#CALC!
842110{3,4}TRUETRUEFALSE
852111{3,4}TRUETRUEFALSE
862210{3,16}#DIV/0!#CALC!#REF!
872211{3,16}#DIV/0!#CALC!#REF!
883010{3,31} 
893011{3,31} 
90
res-c-in-2
Cell Formulas
RangeFormula
F2F2=1/0
J2J2=LAMBDA(reference,[size],[columns],[output_style],[exclude_types],[include_types],[replace_with],[if_empty],LET(r,IF(reference="","",reference),s,TOROW(r),i,COLUMNS(s),t,TOROW(XTYPE(reference,3)),a,MIN(PLSN(size),i),b,PLSL(columns),c,IF(IO(size),0,SWITCH(b,0,1,2)),o,PLS(PO0(output_style)),e,JAL(exclude_types,include_types,replace_with),u,IF(IO(include_types),exclude_types,include_types),v,JAB(u,t),w,SEQUENCE(,i,1,1),x,IF(IO(replace_with),FILTER(w,IF(IO(include_types),NOT(v),v)),IF(IO(include_types),IF(w*v,"",w),IF(w*v,w,""))),y,SWITCH(o,0,IF(e,IF(x="",replace_with,INDEX(s,1,x)),s),1,s),z,SWITCH(o,0,COLUMNS(y),1,i),d,SEQUENCE(SWITCH(c,0,ROUNDUP(z/COLUMNS(reference),0),1,a,ROUNDUP(z/a,0)),SWITCH(c,0,COLUMNS(reference),1,ROUNDUP(z/a,0),MIN(a,z))),f,IF(d<=z,d,""),g,CHOOSEROWS(f,SEQUENCE(SUM(LET(a,BYROW(f,LAMBDA(a,SUM(a))),IF(a>0,1,0))))),h,IF(ISNUMBER(g),INDEX(y,1,g),g),IF(AND(IO(size),NIO(columns)),NA(),JAI(SWITCH(e,0,h,SWITCH(o,0,h,1,JAF(g,exclude_types,include_types,replace_with,h,IF(ISNUMBER(g),INDEX(t,1,g),"")))),if_empty))))
C4C4=IF(1,"")
F8:F18F8=PROCESS($B$2:$H$4,1,1,0,,{1,2})
Q8:Q18Q8=PROCESS($B$2:$H$4,1,1,1,,{1,2})
F19:G24F19=PROCESS($B$2:$H$4,2,1,0,,{1,3})
Q19:R27Q19=PROCESS($B$2:$H$4,2,1,1,,{1,3})
F28:H31F28=PROCESS($B$2:$H$4,3,1,0,,{1,4})
Q28:S33Q28=PROCESS($B$2:$H$4,3,1,1,,{1,4})
F34:I36F34=PROCESS($B$2:$H$4,4,1,0,,{1,16})
Q34:S38Q34=PROCESS($B$2:$H$4,4,1,1,,{1,16})
F39:J40F39=PROCESS($B$2:$H$4,5,1,0,,{1,31})
Q39:U43Q39=PROCESS($B$2:$H$4,5,1,1,,{1,31})
F44:K45F44=PROCESS($B$2:$H$4,6,1,0,,{1,32})
Q44:U46Q44=PROCESS($B$2:$H$4,6,1,1,,{1,32})
F47:L48F47=PROCESS($B$2:$H$4,7,1,0,,{1,41})
Q47:W49Q47=PROCESS($B$2:$H$4,7,1,1,,{1,41})
F50:M50F50=PROCESS($B$2:$H$4,8,1,0,,{1,42})
Q50:V52Q50=PROCESS($B$2:$H$4,8,1,1,,{1,42})
F53:M53F53=PROCESS($B$2:$H$4,9,1,0,,{1,162})
Q53:V54Q53=PROCESS($B$2:$H$4,9,1,1,,{1,162})
F55:M55F55=PROCESS($B$2:$H$4,10,1,0,,{1,164})
F56:L57F56=PROCESS($B$2:$H$4,10,1,1,,{1,164})
F58:M58F58=PROCESS($B$2:$H$4,11,1,0,,{1,1614})
F59:L60F59=PROCESS($B$2:$H$4,11,1,1,,{1,1614})
F61:M61F61=PROCESS($B$2:$H$4,12,1,0,,{2,3})
F62:L63F62=PROCESS($B$2:$H$4,12,1,1,,{2,3})
F64:L64F64=PROCESS($B$2:$H$4,13,1,0,,{2,4})
F65:L66F65=PROCESS($B$2:$H$4,13,1,1,,{2,4})
F67:L67F67=PROCESS($B$2:$H$4,14,1,0,,{2,16})
F68:K69F68=PROCESS($B$2:$H$4,14,1,1,,{2,16})
F70:L70F70=PROCESS($B$2:$H$4,15,1,0,,{2,31})
F71:K72F71=PROCESS($B$2:$H$4,15,1,1,,{2,31})
F73:J73F73=PROCESS($B$2:$H$4,16,1,0,,{2,32})
F74:J74F74=PROCESS($B$2:$H$4,16,1,1,,{2,32})
F75:K75F75=PROCESS($B$2:$H$4,17,1,0,,{2,41})
F76:K76F76=PROCESS($B$2:$H$4,17,1,1,,{2,41})
F77:J77F77=PROCESS($B$2:$H$4,18,1,0,,{2,162})
F78:J78F78=PROCESS($B$2:$H$4,18,1,1,,{2,162})
F79:J79F79=PROCESS($B$2:$H$4,19,1,0,,{2,164})
F80:J81F80=PROCESS($B$2:$H$4,19,1,1,,{2,164})
F82:J82F82=PROCESS($B$2:$H$4,20,1,0,,{2,1614})
F83:J83F83=PROCESS($B$2:$H$4,20,1,1,,{2,1614})
F84:L84F84=PROCESS($B$2:$H$4,21,1,0,,{3,4})
F85:L85F85=PROCESS($B$2:$H$4,21,1,1,,{3,4})
F86:L86F86=PROCESS($B$2:$H$4,22,1,0,,{3,16})
F87:L87F87=PROCESS($B$2:$H$4,22,1,1,,{3,16})
F88:I88F88=PROCESS($B$2:$H$4,30,1,0,,{3,31})
F89:I89F89=PROCESS($B$2:$H$4,30,1,1,,{3,31})
Dynamic array formulas.
 
You must log in or register to reply here.

Forum statistics

Threads
1,216,503
Messages
6,131,022
Members
449,616
Latest member
PsychoCube

Share this page

We've detected that you are using an adblocker.

We have a great community of people providing Excel help here, but the hosting costs are enormous. You can help keep this site running by allowing ads on MrExcel.com.
Allow Ads at MrExcel

Which adblocker are you using?

Disable AdBlock

Follow these easy steps to disable AdBlock

1)Click on the icon in the browser’s toolbar.
2)Click on the icon in the browser’s toolbar.
2)Click on the "Pause on this site" option.
Go back

Disable AdBlock Plus

Follow these easy steps to disable AdBlock Plus

1)Click on the icon in the browser’s toolbar.
2)Click on the toggle to disable it for "mrexcel.com".
Go back

Disable uBlock Origin

Follow these easy steps to disable uBlock Origin

1)Click on the icon in the browser’s toolbar.
2)Click on the "Power" button.
3)Click on the "Refresh" button.
Go back

Disable uBlock

Follow these easy steps to disable uBlock

1)Click on the icon in the browser’s toolbar.
2)Click on the "Power" button.
3)Click on the "Refresh" button.
Go back
Back
Top