Import version 0.1.2

Author: marcosqlbi

src/AbcClassification/README.md

@@ -0,0 +1,110 @@
+# DaxPatterns.AbcClassification
+
+Functions to implement the [ABC Classification](https://www.daxpatterns.com/abc-classification/) pattern (dynamic version) from [DAX Patterns](https://www.daxpatterns.com/).
+
+## What it does
+
+`ComputeInAbcClass` evaluates an expression by filtering the *entity* (e.g., Product, Customer) belongs to the ABC classes active in the filter context from  a disconnected “ABC Classes” table, **respecting all active report filters**. Use it to build dynamic ABC analyses that slice by time, region, or any other dimension. ([daxpatterns.com][1])
+
+---
+
+## Function
+
+```DAX
+ComputeInAbcClass (
+    <valueExpr>,               -- e.g., [Sales Amount] (must be additive, SUM-based)
+    <transactionsTable>,       -- e.g., Sales
+    <itemTable>,               -- e.g., 'Product'
+    <itemKeyColumn>,           -- e.g., 'Product'[ProductKey]
+    <abcClassTable>,           -- e.g., 'ABC Classes' (disconnected)
+    <abcLowerBoundaryColumn>,  -- e.g., 'ABC Classes'[Lower Boundary]  -- inclusive
+    <abcUpperBoundaryColumn]   -- e.g., 'ABC Classes'[Upper Boundary]  -- exclusive (see notes)
+)
+```
+
+**Return:** `TRUE` if the entity’s cumulative share (by `<valueExpr>`) falls within the class boundaries on the current row of `<abcClassTable>`. Otherwise `FALSE`. Use it inside measures to filter or label entities.
+
+**Assumptions:** Dynamic ABC as in the DAX Patterns article with a parameter table of class boundaries. The measure supplied must aggregate with `SUM`. ([daxpatterns.com][1])
+
+---
+
+## Model requirements
+
+1. **Value measure:** Additive, e.g.:
+
+   ```DAX
+   Sales Amount = 
+   SUMX ( Sales, Sales[Quantity] * Sales[Net Price] )
+   ```
+2. **Entity table:** The table that lists the items to classify (e.g., `Product`).
+3. **Classes table (disconnected):** No relationships. Contains at least:
+
+   * `Class` (A/B/C or any label)
+   * `Lower Boundary` (0–1)
+   * `Upper Boundary` (0–1)
+
+Example `ABC Classes` (typical Pareto configuration):
+
+```DAX
+ABC Classes = 
+DATATABLE (
+    "Class", STRING,
+    "Lower Boundary", DOUBLE,
+    "Upper Boundary", DOUBLE,
+{
+    { "A", 0.00, 0.70 },
+    { "B", 0.70, 0.90 },
+    { "C", 0.90, 1.00 }
+})
+```
+
+This matches the pattern described in DAX Patterns and its dynamic variant (classification driven by a disconnected parameter table). ([daxpatterns.com][1])
+
+---
+
+## Basic usage
+
+```DAX
+ABC Sales Amount =
+ComputeInAbcClass (
+    [Sales Amount],
+    Sales,
+    'Product',
+    'Product'[ProductKey],
+    'ABC Classes',
+    'ABC Classes'[Lower Boundary], 
+    'ABC Classes'[Upper Boundary]
+)
+
+```
+
+These produce a **dynamic** ABC where class membership updates with filters (e.g., year, region). ([daxpatterns.com][1])
+
+---
+
+## Tips, constraints, and performance
+
+* **Additivity:** `<valueExpr>` must be SUM-based for correct cumulative ranking in the dynamic pattern. Non-additive measures break the logic. ([daxpatterns.com][1])
+* **Boundaries:** Treat `Lower Boundary` as inclusive and `Upper Boundary` as exclusive to avoid overlaps at exact cut points (e.g., 0.70 belongs to B if A ends at 0.70).
+* **Disconnected classes:** Do **not** relate `ABC Classes` to other tables. It is a parameter table used by the measure. ([daxpatterns.com][2])
+* **Granularity:** Pass the **entity key** that defines classification granularity.
+* **Scaling:** With very high entity cardinality, consider pre-aggregation by entity or snapshot ABC when dynamics are not needed. ([daxpatterns.com][1])
+
+---
+
+## Related reading
+
+* DAX Patterns — ABC classification (static, snapshot, dynamic). ([daxpatterns.com][1])
+* DAX Patterns — Dynamic ABC Classification (concepts and step-by-step). ([daxpatterns.com][1])
+* Parameter Table pattern. ([daxpatterns.com][2])
+* DAX Lib package list (package reference). ([daxlib.org][3])
+
+---
+
+## License
+
+MIT License.
+
+[1]: https://www.daxpatterns.com/abc-classification/ "ABC classification"
+[2]: https://www.daxpatterns.com/parameter-table/ "Parameter table"
+[3]: https://daxlib.org/packages/ "Packages - Extend Power BI with DAX Lib"

src/AbcClassification/icon.png

@@ -0,0 +1,115 @@
+/// Return the value computed in the filtered ABC classes
+/// Implement Dynamic ABC Classification pattern from DAX Patterns
+/// Article: https://www.daxpatterns.com/abc-classification/
+/// You must have a table with the definition of 
+/// the ABC classes (abcClassTable) with at least two columns,
+/// the lower and the upper boundary of each class
+/// The first argument is the expression to evaluate for each 
+/// ite in itemTable, which cardinality is expressed by itemKeyColumn
+/// The transactionTable is the table that defines the presence of
+/// transactions, typically the table that has the column(s) 
+/// aggregated in valueExpr
+function 'DaxPatterns.AbcClassification.ComputeInAbcClass' = ```
+        ( 
+            valueExpr : ANYREF EXPR, 
+            transactionsTable : ANYREF EXPR, 
+            itemTable : ANYREF EXPR, 
+            itemKeyColumn : ANYREF EXPR,
+            abcClassTable : ANYREF EXPR,
+            abcLowerBoundaryColumn : ANYREF EXPR,
+            abcUpperBoundaryColumn : ANYREF EXPR
+        ) =>
+            VAR ProductsInClass = 
+                DaxPatterns.AbcClassification.ItemsInClass( 
+                    valueExpr,
+                    TransactionsTable, 
+                    ItemTable, 
+                    ItemKeyColumn, 
+                    abcClassTable,
+                    abcLowerBoundaryColumn,
+                    abcUpperBoundaryColumn 
+                ) 
+            VAR Result =
+                CALCULATE (           
+                    valueExpr,
+                    KEEPFILTERS ( ProductsInClass )
+                )
+            RETURN Result
+        ```
+    annotation DAXLIB_PackageId = DaxPatterns.AbcClassification
+
+    annotation DAXLIB_PackageVersion = 0.1.2
+
+/// Return the items filtered by ABC classes
+/// Implement Dynamic ABC Classification pattern from DAX Patterns
+/// Article: https://www.daxpatterns.com/abc-classification/
+/// You must have a table with the definition of 
+/// the ABC classes (abcClassTable) with at least two columns,
+/// the lower and the upper boundary of each class
+/// The first argument is the expression to evaluate for each 
+/// ite in itemTable, which cardinality is expressed by itemKeyColumn
+/// The transactionTable is the table that defines the presence of
+/// transactions, typically the table that has the column(s) 
+/// aggregated in valueExpr
+function 'DaxPatterns.AbcClassification.ItemsInClass' = ```
+        ( 
+            valueExpr : ANYREF EXPR,
+            transactionsTable : ANYREF EXPR, 
+            itemTable : ANYREF EXPR, 
+            itemKeyColumn : ANYREF EXPR, 
+            abcClassTable : ANYREF EXPR,
+            abcLowerBoundaryColumn : ANYREF EXPR,
+            abcUpperBoundaryColumn : ANYREF EXPR
+        ) => 
+            VAR TransactionsByItem = 	
+                CALCULATETABLE (
+                    ADDCOLUMNS (
+                        SUMMARIZE ( transactionsTable, itemKeyColumn ),
+                        "@Value", CALCULATE ( valueExpr )
+                    ),
+                    ALLSELECTED ( itemTable )
+                )
+            VAR AllItemsValue =
+                SUMX ( 
+                    transactionsByItem,
+                    [@Value]
+                )
+            VAR CumulatedPctByItemTable = 
+                ADDCOLUMNS ( 
+                    transactionsByItem, 
+                    "@CumulatedPct", 
+                        VAR CumulatedValue = 
+                            SUMX ( 
+                                WINDOW ( 
+                                    1, ABS, 
+                                    0, REL, 
+                                    transactionsByItem, 
+                                    ORDERBY ( [@Value], DESC ) 
+                                ), 
+                                [@Value] 
+                            )
+                        VAR Perc = 
+                            DIVIDE (
+                                CumulatedValue,
+                                AllItemsValue
+                            )
+                        RETURN
+                            MIN ( Perc, 1 ) -- Avoid >100% in case of rounding issues
+                )
+            
+            VAR Result =
+                FILTER (
+                    CROSSJOIN (
+                        CumulatedPctByItemTable,
+                        abcClassTable
+                    ),
+                    AND (
+                        [@CumulatedPct] > abcLowerBoundaryColumn,
+                        [@CumulatedPct] <= abcUpperBoundaryColumn
+                    )
+                )
+            RETURN Result
+        ```
+    annotation DAXLIB_PackageId = DaxPatterns.AbcClassification
+
+    annotation DAXLIB_PackageVersion = 0.1.2

src/AbcClassification/lib/functions.tmdl

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://raw.githubusercontent.com/sql-bi/daxlib/refs/heads/main/schemas/manifest/1.0.0/manifest.1.0.0.schema.json",
+  "id": "DaxPatterns.AbcClassification",
+  "version": "0.1.2",
+  "authors": "SQLBI",
+  "description": "Implementation of ABC Classification patterns using User Defined Functions.",
+  "tags": "DAX,UDF,FUNCTION,LIB,PATTERN,ABC",
+  "icon": "/icon.png",
+  "readme": "/README.md"
+}