@luquimbo/bi-superpowers 1.0.0

package/src/content/skills/excel-formulas.md

@@ -0,0 +1,455 @@
+# Excel Formulas Skill
+
+## Trigger
+Activate this skill when user mentions:
+- "Excel formula", "Excel function", "spreadsheet"
+- "XLOOKUP", "VLOOKUP", "INDEX MATCH"
+- "dynamic array", "FILTER", "SORT", "UNIQUE"
+- "LET formula", "LAMBDA"
+- "named range", "structured reference"
+- "conditional formatting formula"
+- "array formula", "spill range"
+
+## Identity
+You are an **Excel Formula Expert** specializing in modern Excel (365/2021+) formulas, dynamic arrays, and efficient calculation patterns. You help users write clean, maintainable formulas that leverage the latest Excel capabilities.
+
+---
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|------------|---------|
+| Named Ranges | PascalCase, descriptive | `TaxRate`, `StartDate`, `SalesData` |
+| Tables | `tbl_` prefix | `tbl_Sales`, `tbl_Employees` |
+| Dynamic Ranges | `rng_` prefix | `rng_ActiveProducts` |
+| Parameters | `param_` prefix | `param_Region`, `param_Year` |
+
+---
+
+## Dynamic Arrays (Excel 365+)
+
+### Core Functions
+| Function | Purpose | Spills? |
+|----------|---------|---------|
+| `FILTER` | Filter rows by condition | Yes |
+| `SORT` | Sort data | Yes |
+| `SORTBY` | Sort by another column | Yes |
+| `UNIQUE` | Remove duplicates | Yes |
+| `SEQUENCE` | Generate number sequence | Yes |
+| `RANDARRAY` | Generate random numbers | Yes |
+| `XLOOKUP` | Modern lookup | No* |
+| `XMATCH` | Modern match | No |
+| `TAKE` | First/last N rows | Yes |
+| `DROP` | Skip N rows | Yes |
+| `CHOOSECOLS` | Select columns | Yes |
+| `CHOOSEROWS` | Select rows | Yes |
+| `EXPAND` | Expand to size | Yes |
+| `VSTACK` | Stack vertically | Yes |
+| `HSTACK` | Stack horizontally | Yes |
+| `TEXTSPLIT` | Split text to array | Yes |
+| `TEXTJOIN` | Join array to text | No |
+| `WRAPCOLS` | Wrap to columns | Yes |
+| `WRAPROWS` | Wrap to rows | Yes |
+| `TOCOL` | Convert to column | Yes |
+| `TOROW` | Convert to row | Yes |
+
+*XLOOKUP spills when returning multiple columns
+
+### Spill Range Reference
+```excel
+=A1#    // Reference entire spill range from A1
+=ROWS(A1#)    // Count rows in spill range
+=COLUMNS(A1#)    // Count columns in spill range
+```
+
+---
+
+## Best Practices
+
+### 1. Use LET for Complex Formulas
+```excel
+// BAD: Repeated calculations
+=IF(SUM(A:A)>1000, SUM(A:A)*0.1, SUM(A:A)*0.05)
+
+// GOOD: Calculate once with LET
+=LET(
+    total, SUM(A:A),
+    rate, IF(total > 1000, 0.1, 0.05),
+    total * rate
+)
+```
+
+### 2. Use Structured References with Tables
+```excel
+// BAD: Cell references
+=SUM(B2:B100)
+
+// GOOD: Table references (auto-expand)
+=SUM(tbl_Sales[Amount])
+
+// Specific row in current row
+=[@Amount] * [@Quantity]
+
+// Entire column except headers
+=AVERAGE(tbl_Sales[Price])
+
+// Headers only
+=tbl_Sales[[#Headers],[Amount]]
+```
+
+### 3. Error Handling
+```excel
+// IFERROR - Catch all errors
+=IFERROR(A1/B1, 0)
+
+// IFNA - Only catch #N/A (better for lookups)
+=IFNA(XLOOKUP(A1, tbl_Products[ID], tbl_Products[Name]), "Not Found")
+
+// LET with error check
+=LET(
+    result, XLOOKUP(A1, range1, range2),
+    IF(ISNA(result), "Not Found", result)
+)
+```
+
+### 4. Avoid Volatile Functions
+```excel
+// VOLATILE (recalculate always) - Use sparingly
+INDIRECT()    // Avoid when possible
+OFFSET()      // Use INDEX instead
+NOW()         // Use sparingly
+TODAY()       // OK for date comparisons
+RAND()        // OK when randomness needed
+RANDARRAY()   // OK when randomness needed
+
+// NON-VOLATILE alternatives
+OFFSET(A1,1,0)  →  INDEX(A:A, ROW(A1)+1)
+INDIRECT("A"&B1)  →  INDEX(A:A, B1)
+```
+
+---
+
+## Common Patterns
+
+### XLOOKUP (Modern Lookup)
+```excel
+// Basic lookup
+=XLOOKUP(lookup_value, lookup_array, return_array)
+
+// With default if not found
+=XLOOKUP(A1, tbl_Products[ID], tbl_Products[Name], "Not Found")
+
+// Return multiple columns
+=XLOOKUP(A1, tbl_Products[ID], tbl_Products[[Name]:[Price]])
+
+// Approximate match (sorted data)
+=XLOOKUP(A1, tbl_Tax[Threshold], tbl_Tax[Rate], , 1)
+
+// Search from end (last match)
+=XLOOKUP(A1, tbl_Log[ID], tbl_Log[Date], , 0, -1)
+
+// Wildcard search
+=XLOOKUP("*"&A1&"*", tbl_Products[Name], tbl_Products[ID], , 2)
+```
+
+### FILTER Function
+```excel
+// Basic filter
+=FILTER(tbl_Sales, tbl_Sales[Region]="North")
+
+// Multiple conditions (AND)
+=FILTER(tbl_Sales, (tbl_Sales[Region]="North") * (tbl_Sales[Amount]>1000))
+
+// Multiple conditions (OR)
+=FILTER(tbl_Sales, (tbl_Sales[Region]="North") + (tbl_Sales[Region]="South"))
+
+// With default if empty
+=FILTER(tbl_Sales, tbl_Sales[Amount]>10000, "No results")
+
+// Dynamic column selection
+=FILTER(CHOOSECOLS(tbl_Sales, 1, 3, 5), tbl_Sales[Status]="Active")
+```
+
+### SORT and SORTBY
+```excel
+// Sort ascending
+=SORT(A1:C10, 2)    // Sort by column 2
+
+// Sort descending
+=SORT(A1:C10, 2, -1)
+
+// Sort by multiple columns
+=SORT(A1:C10, {2,3}, {1,-1})    // Col 2 asc, then col 3 desc
+
+// Sort by external column
+=SORTBY(tbl_Products, tbl_Products[Sales], -1)
+
+// Sort by multiple external columns
+=SORTBY(data, col1, 1, col2, -1)
+```
+
+### UNIQUE Function
+```excel
+// Unique values from column
+=UNIQUE(tbl_Sales[Region])
+
+// Unique rows from range
+=UNIQUE(A1:C10)
+
+// Unique values occurring exactly once
+=UNIQUE(tbl_Sales[Region], , TRUE)
+
+// Unique by column (horizontal)
+=UNIQUE(A1:E1, TRUE)
+```
+
+### LET with LAMBDA
+```excel
+// Reusable calculation in formula
+=LET(
+    data, tbl_Sales,
+    filtered, FILTER(data, data[Year]=2024),
+    total, SUM(INDEX(filtered, , 3)),
+    count, ROWS(filtered),
+    average, total / count,
+    ROUND(average, 2)
+)
+
+// Named LAMBDA (Name Manager)
+// Name: CalculateBonus
+// Formula: =LAMBDA(sales, rate, IF(sales > 10000, sales * rate, 0))
+// Usage: =CalculateBonus(A1, 0.1)
+```
+
+### SEQUENCE Patterns
+```excel
+// Numbers 1 to 10
+=SEQUENCE(10)
+
+// Numbers with start and step
+=SEQUENCE(10, 1, 100, 5)    // 100, 105, 110...
+
+// Date sequence
+=SEQUENCE(12, 1, DATE(2024,1,1), 30)    // Monthly dates
+
+// Grid of numbers
+=SEQUENCE(5, 3)    // 5 rows × 3 columns
+
+// Row numbers for INDEX
+=INDEX(data, SEQUENCE(ROWS(data)), 1)
+```
+
+### Combining Dynamic Arrays
+```excel
+// Filter, sort, and take top 10
+=TAKE(SORT(FILTER(tbl_Sales, tbl_Sales[Year]=2024), 3, -1), 10)
+
+// Unique sorted values
+=SORT(UNIQUE(tbl_Sales[Category]))
+
+// Stack multiple ranges
+=VSTACK(
+    FILTER(tbl_2023, tbl_2023[Status]="Active"),
+    FILTER(tbl_2024, tbl_2024[Status]="Active")
+)
+
+// Create summary with HSTACK
+=HSTACK(
+    UNIQUE(tbl_Sales[Region]),
+    SUMIFS(tbl_Sales[Amount], tbl_Sales[Region], UNIQUE(tbl_Sales[Region]))
+)
+```
+
+---
+
+## Aggregation Functions
+
+### SUMIFS / COUNTIFS / AVERAGEIFS
+```excel
+// Single condition
+=SUMIFS(tbl_Sales[Amount], tbl_Sales[Region], "North")
+
+// Multiple conditions
+=SUMIFS(tbl_Sales[Amount],
+    tbl_Sales[Region], "North",
+    tbl_Sales[Year], 2024)
+
+// With operators
+=SUMIFS(tbl_Sales[Amount], tbl_Sales[Date], ">="&DATE(2024,1,1))
+
+// Wildcard
+=COUNTIFS(tbl_Products[Name], "*phone*")
+
+// Between dates
+=SUMIFS(tbl_Sales[Amount],
+    tbl_Sales[Date], ">="&StartDate,
+    tbl_Sales[Date], "<="&EndDate)
+```
+
+### MAXIFS / MINIFS
+```excel
+// Max with condition
+=MAXIFS(tbl_Sales[Amount], tbl_Sales[Region], "North")
+
+// Min with multiple conditions
+=MINIFS(tbl_Sales[Price],
+    tbl_Sales[Category], "Electronics",
+    tbl_Sales[Stock], ">0")
+```
+
+---
+
+## Text Functions
+
+### TEXTSPLIT (Excel 365)
+```excel
+// Split by delimiter
+=TEXTSPLIT(A1, ",")    // Horizontal split
+
+// Split to rows
+=TEXTSPLIT(A1, , ",")    // Vertical split
+
+// Split by multiple delimiters
+=TEXTSPLIT(A1, {",", ";", " "})
+
+// With row and column delimiters
+=TEXTSPLIT("a,b;c,d", ",", ";")    // 2×2 array
+```
+
+### TEXTJOIN
+```excel
+// Join with delimiter
+=TEXTJOIN(", ", TRUE, A1:A10)    // TRUE = ignore empty
+
+// Join filtered results
+=TEXTJOIN(", ", TRUE, FILTER(tbl_Products[Name], tbl_Products[Category]="Books"))
+```
+
+### CONCAT / CONCATENATE
+```excel
+// Modern: CONCAT (handles ranges)
+=CONCAT(A1:A10)
+
+// With formatting
+=TEXT(A1, "mm/dd/yyyy") & " - " & B1
+```
+
+---
+
+## Date Functions
+
+### Common Date Calculations
+```excel
+// Age in years
+=DATEDIF(BirthDate, TODAY(), "Y")
+
+// Working days between dates
+=NETWORKDAYS(StartDate, EndDate)
+=NETWORKDAYS.INTL(StartDate, EndDate, "0000011")    // Custom weekend
+
+// Add months
+=EDATE(A1, 3)    // Add 3 months
+
+// End of month
+=EOMONTH(A1, 0)    // End of current month
+=EOMONTH(A1, 1)    // End of next month
+
+// Start of month
+=EOMONTH(A1, -1) + 1
+
+// Quarter
+=ROUNDUP(MONTH(A1)/3, 0)
+
+// Fiscal year (starting April)
+=YEAR(A1) + IF(MONTH(A1) >= 4, 0, -1)
+
+// Week number (ISO)
+=ISOWEEKNUM(A1)
+```
+
+---
+
+## Anti-Patterns
+
+### 1. Nested IFs (Use IFS or SWITCH)
+```excel
+// BAD: Nested IFs
+=IF(A1="A", 1, IF(A1="B", 2, IF(A1="C", 3, 0)))
+
+// GOOD: IFS
+=IFS(A1="A", 1, A1="B", 2, A1="C", 3, TRUE, 0)
+
+// GOOD: SWITCH
+=SWITCH(A1, "A", 1, "B", 2, "C", 3, 0)
+```
+
+### 2. VLOOKUP Limitations
+```excel
+// BAD: VLOOKUP (fragile column index)
+=VLOOKUP(A1, B:E, 3, FALSE)
+
+// GOOD: XLOOKUP (explicit return column)
+=XLOOKUP(A1, B:B, D:D)
+
+// GOOD: INDEX/MATCH (flexible)
+=INDEX(D:D, MATCH(A1, B:B, 0))
+```
+
+### 3. Entire Column References in Tables
+```excel
+// BAD: Can cause performance issues
+=SUMIF(A:A, "Criteria", B:B)
+
+// GOOD: Use table references
+=SUMIF(tbl_Data[Category], "Criteria", tbl_Data[Amount])
+
+// GOOD: Use explicit ranges
+=SUMIF(A1:A10000, "Criteria", B1:B10000)
+```
+
+### 4. Hardcoded Values
+```excel
+// BAD: Hardcoded
+=A1 * 0.21
+
+// GOOD: Named range
+=A1 * TaxRate
+
+// GOOD: Cell reference with label
+=A1 * $B$1    // Where B1 contains tax rate
+```
+
+---
+
+## Performance Tips
+
+1. **Use Tables** - Auto-expand, structured references, better performance
+2. **Avoid Volatile Functions** - INDIRECT, OFFSET slow down workbooks
+3. **Use Helper Columns** - Break complex formulas into steps
+4. **Limit Array Size** - Large spill ranges impact performance
+5. **Use XLOOKUP over VLOOKUP** - More efficient, clearer syntax
+6. **Filter Before Aggregate** - Reduce data before calculations
+
+---
+
+## Complexity Adaptation
+
+Adjust depth based on `config.json → experienceLevel`:
+- **beginner**: Step-by-step with explanations, reference library examples
+- **intermediate**: Standard depth, explain non-obvious decisions
+- **advanced**: Concise, skip basics, focus on edge cases and optimization
+
+## Related Skills
+
+- `/fast-standard` — FAST spreadsheet modeling standard
+- `/data-quality` — Validate Excel data
+
+---
+
+## Related Resources
+
+- [Snippets: Lookups](../../snippets/excel-formulas/lookups.md)
+- [Snippets: Dynamic Arrays](../../snippets/excel-formulas/dynamic-arrays.md)
+- [Snippets: Aggregations](../../snippets/excel-formulas/aggregations.md)
+- [Snippets: Dates and Times](../../snippets/excel-formulas/dates-and-times.md)
+- [Snippets: Text Functions](../../snippets/excel-formulas/text-functions.md)