DAX

DEFINE
    /// Ano fiscal da data, identificado pelo ano em que termina.
    /// @param {DATETIME} pDate - Data.
    /// @param {INT64} pStartMonth - Mês de início do ano fiscal (1 a 12).
    /// @returns Ano fiscal. Com início em janeiro, é o próprio ano civil.
    FUNCTION Date.FiscalYear =
        ( pDate : DATETIME VAL, pStartMonth : INT64 VAL ) =>
        YEAR ( pDate ) + IF ( pStartMonth > 1 && MONTH ( pDate ) >= pStartMonth, 1, 0 )

EVALUATE
{ Date.FiscalYear ( DATE ( 2025, 8, 1 ), 7 ), Date.FiscalYear ( DATE ( 2025, 8, 1 ), 1 ) }  // 2026 · 2025

DEFINE
    /// Mês fiscal da data (1 = mês de início do ano fiscal).
    /// @param {DATETIME} pDate - Data.
    /// @param {INT64} pStartMonth - Mês de início do ano fiscal (1 a 12).
    /// @returns Mês fiscal, de 1 a 12.
    FUNCTION Date.FiscalMonth =
        ( pDate : DATETIME VAL, pStartMonth : INT64 VAL ) =>
        MOD ( MONTH ( pDate ) - pStartMonth + 12, 12 ) + 1

EVALUATE
{ Date.FiscalMonth ( DATE ( 2025, 8, 1 ), 7 ) }  // 2

DEFINE
    /// Rótulo do ano fiscal: "AA-AA" (início-fim), ou o ano com quatro dígitos quando o ano fiscal começa em janeiro.
    /// @param {DATETIME} pDate - Data.
    /// @param {INT64} pStartMonth - Mês de início do ano fiscal (1 a 12).
    /// @returns Texto, ex.: "24-25".
    FUNCTION Date.FiscalYearLabel =
        ( pDate : DATETIME VAL, pStartMonth : INT64 VAL ) =>
        VAR vDateYear = YEAR ( pDate )
        VAR vFiscalStartYear = IF ( MONTH ( pDate ) >= pStartMonth, vDateYear, vDateYear - 1 )
        RETURN
            IF (
                pStartMonth = 1,
                FORMAT ( vDateYear, "0" ),
                FORMAT ( MOD ( vFiscalStartYear, 100 ), "00" ) & "-" & FORMAT ( MOD ( vFiscalStartYear + 1, 100 ), "00" )
            )

EVALUATE
{ Date.FiscalYearLabel ( DATE ( 2024, 7, 1 ), 7 ), Date.FiscalYearLabel ( DATE ( 2025, 3, 1 ), 1 ) }  // "24-25" · "2025"

DEFINE
    /// Trimestre fiscal da data.
    /// @param {DATETIME} pDate - Data.
    /// @param {INT64} pStartMonth - Mês de início do ano fiscal (1 a 12).
    /// @returns Trimestre fiscal, de 1 a 4.
    FUNCTION Date.FiscalQuarter =
        ( pDate : DATETIME VAL, pStartMonth : INT64 VAL ) =>
        VAR vShiftedMonth = MOD ( MONTH ( pDate ) - pStartMonth + 12, 12 ) + 1
        RETURN
            ROUNDUP ( vShiftedMonth / 3, 0 )

EVALUATE
{ Date.FiscalQuarter ( DATE ( 2025, 5, 15 ), 7 ) }  // 4

DEFINE
    /// Gera uma tabela calendário com colunas gregorianas, ISO 8601, fiscais e estação do ano.
    /// @param {DATETIME} StartDate - Primeira data (inclusive).
    /// @param {DATETIME} EndDate - Última data (inclusive).
    /// @param {STRING} Locale - Cultura dos nomes de mês e dia, ex.: "pt-BR".
    /// @param {INT64} FirstDay - Início da semana, nos códigos de WEEKNUM: 1, 2, 11 a 17 ou 21 (ISO).
    /// @param {INT64} FiscalYearStartMonth - Mês de início do ano fiscal (1 a 12). O ano fiscal leva o número do ano em que termina.
    /// @param {STRING} Hemisphere - Opcional. "S" (padrão) ou "N": hemisfério usado nas estações do ano.
    /// @returns Tabela com uma linha por dia.
    FUNCTION DataHora.Calendario =
        (
            StartDate : SCALAR DATETIME VAL,
            EndDate : SCALAR DATETIME VAL,
            Locale : SCALAR STRING VAL,
            FirstDay : SCALAR INT64 VAL,
            FiscalYearStartMonth : SCALAR INT64 VAL,
            Hemisphere : SCALAR STRING VAL = "S"
        ) =>
        -- Dia em que a semana começa, na escala de WEEKDAY(data, 2): 1 = segunda ... 7 = domingo.
        -- WEEKDAY só aceita 1, 2 ou 3; os códigos 11 a 17 e 21 de WEEKNUM são convertidos aqui.
        VAR vInicioSemana =
            SWITCH (
                FirstDay,
                1, 7,  2, 1,  11, 1,  12, 2,  13, 3,
                14, 4, 15, 5, 16, 6,  17, 7,  21, 1,
                7
            )
        -- Hemisfério das estações: "N", "Norte" ou "North" = norte; qualquer outro valor = sul
        VAR vNorte = UPPER ( LEFT ( Hemisphere, 1 ) ) = "N"
        -- Idioma dos nomes das estações: pt e es; as demais culturas recebem inglês
        VAR vIdioma = LOWER ( LEFT ( Locale, 2 ) )
        VAR vCalendario =
            SELECTCOLUMNS ( CALENDAR ( StartDate, EndDate ), "Data Referência", [Date] )
        RETURN
            ADDCOLUMNS (
                vCalendario,
                "Data (AAAAMMDD)", FORMAT ( [Data Referência], "YYYYMMDD" ),
                "Data (ddd dd/mm/aaaa)", FORMAT ( [Data Referência], "DDD DD/MM/YYYY", Locale ),
                "Ano", YEAR ( [Data Referência] ),
                "Semestre #", IF ( MONTH ( [Data Referência] ) <= 6, 1, 2 ),
                "Semestre", "S" & IF ( MONTH ( [Data Referência] ) <= 6, 1, 2 ),
                "Trimestre #", QUARTER ( [Data Referência] ),
                "Trimestre", "T" & FORMAT ( [Data Referência], "Q" ),
                "Ano/Trimestre", FORMAT ( [Data Referência], "YYYY" ) & "/T" & FORMAT ( [Data Referência], "Q" ),
                "Mês #", MONTH ( [Data Referência] ),
                "Mês", FORMAT ( [Data Referência], "MMMM", Locale ),
                "Mês (Abreviado)", FORMAT ( [Data Referência], "MMM", Locale ),
                "Ano/Mês", FORMAT ( [Data Referência], "YYYY/MM" ),
                "Ano/Mês (Abreviado)", FORMAT ( [Data Referência], "YYYY/MMM", Locale ),
                "Semana #", WEEKNUM ( [Data Referência], FirstDay ),
                "Semana", WEEKNUM ( [Data Referência], FirstDay ) & "ª semana",
                -- Semana do mês de 1 a 6, contada a partir do dia em que a semana começa
                "Semana do Mês",
                    VAR vPrimeiroDia = DATE ( YEAR ( [Data Referência] ), MONTH ( [Data Referência] ), 1 )
                    VAR vDesloc = MOD ( WEEKDAY ( vPrimeiroDia, 2 ) - vInicioSemana + 7, 7 )
                    RETURN INT ( ( DAY ( [Data Referência] ) + vDesloc - 1 ) / 7 ) + 1,
                "Quinzena #", IF ( DAY ( [Data Referência] ) <= 15, 1, 2 ),
                "Quinzena", "Qz" & IF ( DAY ( [Data Referência] ) <= 15, 1, 2 ),
                -- 1 = primeiro dia da semana definido em FirstDay
                "Dia da Semana #", MOD ( WEEKDAY ( [Data Referência], 2 ) - vInicioSemana + 7, 7 ) + 1,
                "Dia da Semana", FORMAT ( [Data Referência], "dddd", Locale ),
                "Dia da Semana (Abreviado)", FORMAT ( [Data Referência], "ddd", Locale ),
                -- Verdadeiro/falso: sábado ou domingo
                "Fim-de-Semana", WEEKDAY ( [Data Referência], 2 ) >= 6,
                -- Estação meteorológica por trimestre de meses: 1 = dez a fev ... 4 = set a nov (use para classificar Estação)
                "Estação #", INT ( MOD ( MONTH ( [Data Referência] ), 12 ) / 3 ) + 1,
                "Estação",
                    VAR vTrimestre = INT ( MOD ( MONTH ( [Data Referência] ), 12 ) / 3 ) + 1
                    -- 1 = verão, 2 = outono, 3 = inverno, 4 = primavera; no norte, dez a fev é inverno
                    VAR vEstacao = IF ( vNorte, MOD ( vTrimestre + 1, 4 ) + 1, vTrimestre )
                    RETURN
                        SWITCH (
                            vEstacao,
                            1, "☀️ " & SWITCH ( vIdioma, "pt", "Verão", "es", "Verano", "Summer" ),
                            2, "🍂 " & SWITCH ( vIdioma, "pt", "Outono", "es", "Otoño", "Autumn" ),
                            3, "❄️ " & SWITCH ( vIdioma, "pt", "Inverno", "es", "Invierno", "Winter" ),
                            "🌸 " & SWITCH ( vIdioma, "pt", "Primavera", "es", "Primavera", "Spring" )
                        ),
                "Dia do Ano", DATEDIFF ( DATE ( YEAR ( [Data Referência] ), 1, 1 ), [Data Referência], DAY ) + 1,
                "Dia", DAY ( [Data Referência] ),
                "Início do Mês", DATE ( YEAR ( [Data Referência] ), MONTH ( [Data Referência] ), 1 ),
                "Fim do Mês", EOMONTH ( [Data Referência], 0 ),
                "Início do Trimestre", DATE ( YEAR ( [Data Referência] ), ( QUARTER ( [Data Referência] ) - 1 ) * 3 + 1, 1 ),
                "Fim do Trimestre", EOMONTH ( DATE ( YEAR ( [Data Referência] ), ( QUARTER ( [Data Referência] ) - 1 ) * 3 + 1, 1 ), 2 ),
                "Início do Ano", DATE ( YEAR ( [Data Referência] ), 1, 1 ),
                "Fim do Ano", DATE ( YEAR ( [Data Referência] ), 12, 31 ),
                "Semana ISO #", WEEKNUM ( [Data Referência], 21 ),
                -- Ano ISO = ano da quinta-feira da mesma semana
                "Ano ISO", YEAR ( [Data Referência] - ( WEEKDAY ( [Data Referência], 2 ) - 4 ) ),
                "Ano-Semana ISO",
                    YEAR ( [Data Referência] - ( WEEKDAY ( [Data Referência], 2 ) - 4 ) )
                        & "-" & RIGHT ( "00" & WEEKNUM ( [Data Referência], 21 ), 2 ),
                "Mês Fiscal #", MOD ( MONTH ( [Data Referência] ) - FiscalYearStartMonth + 12, 12 ) + 1,
                "Trimestre Fiscal #", ROUNDUP ( ( MOD ( MONTH ( [Data Referência] ) - FiscalYearStartMonth + 12, 12 ) + 1 ) / 3, 0 ),
                -- Ano fiscal = ano em que termina. Com início em janeiro, coincide com o ano civil.
                "Ano Fiscal #",
                    YEAR ( [Data Referência] )
                        + IF ( FiscalYearStartMonth > 1 && MONTH ( [Data Referência] ) >= FiscalYearStartMonth, 1, 0 ),
                "Ano Fiscal",
                    VAR vFYFim =
                        YEAR ( [Data Referência] )
                            + IF ( FiscalYearStartMonth > 1 && MONTH ( [Data Referência] ) >= FiscalYearStartMonth, 1, 0 )
                    RETURN
                        IF (
                            FiscalYearStartMonth = 1,
                            FORMAT ( vFYFim, "0" ),
                            RIGHT ( "0" & MOD ( vFYFim - 1, 100 ), 2 ) & "-" & RIGHT ( "0" & MOD ( vFYFim, 100 ), 2 )
                        )
            )

EVALUATE
DataHora.Calendario ( DATE ( 2026, 1, 1 ), DATE ( 2026, 12, 31 ), "pt-BR", 2, 7 )

-- Estações no hemisfério norte, em inglês: uma linha por mês
EVALUATE
FILTER (
    SELECTCOLUMNS (
        DataHora.Calendario ( DATE ( 2026, 1, 1 ), DATE ( 2026, 12, 31 ), "en-US", 2, 1, "N" ),
        "Data", [Data Referência],
        "Estação #", [Estação #],
        "Estação", [Estação]
    ),
    DAY ( [Data] ) = 1
)
-- jan e fev = ❄️ Winter · mar a mai = 🌸 Spring · jun a ago = ☀️ Summer · set a nov = 🍂 Autumn · dez = ❄️ Winter

DEFINE
    /// Retorna a descrição da biblioteca DataHora (nome, versão, função e exemplo).
    /// @returns Texto de várias linhas.
    FUNCTION DataHora.Sobre =
        () =>
        VAR vLB = UNICHAR ( 10 )
        RETURN
            "📚 Biblioteca: DataHora" & vLB
                & "🧑 Autor: Paulo André Jesus" & vLB
                & "🛠️ Versão: 1.2.0" & vLB
                & "📌 Categoria: Calendário / Tempo" & vLB & vLB
                & "Função:" & vLB
                & "• DataHora.Calendario(StartDate, EndDate, Locale, FirstDay, FiscalYearStartMonth [, Hemisphere])" & vLB & vLB
                & "Exemplo:" & vLB
                & "EVALUATE DataHora.Calendario(DATE(2025,1,1), DATE(2025,12,31), ""pt-BR"", 1, 9)" & vLB & vLB
                & "⚠️ Após criar a tabela, marque-a como Tabela de Datas no Power BI."

EVALUATE
{ DataHora.Sobre ( ) }

DEFINE
    /// Valor do mesmo período do ano anterior.
    /// Requer a tabela 'TabDimCalendario', coluna [Data Referência], marcada como Tabela de Datas.
    /// @param {ANYREF} Valor - Medida ou expressão a recalcular no ano anterior.
    /// @returns Valor no mesmo período do ano anterior.
    FUNCTION Delta.AA =
        ( Valor : ANYREF ) =>
        CALCULATE ( Valor, SAMEPERIODLASTYEAR ( 'TabDimCalendario'[Data Referência] ) )

EVALUATE
{ Delta.AA ( [Total Vendas] ) }  // troque [Total Vendas] por uma medida do seu modelo

DEFINE
    /// Diferença entre o valor atual e o do ano anterior.
    /// @param {ANYVAL} Valor - Valor atual.
    /// @param {ANYVAL} ValorAA - Valor do ano anterior.
    /// @returns Valor − ValorAA, ou BLANK se um dos dois estiver em branco.
    FUNCTION Delta.Absoluto =
        ( Valor : ANYVAL, ValorAA : ANYVAL ) =>
        IF ( ISBLANK ( Valor ) || ISBLANK ( ValorAA ), BLANK (), Valor - ValorAA )

EVALUATE
{ Delta.Absoluto ( 120, 100 ) }  // 20

DEFINE
    /// Variação percentual sobre o ano anterior.
    /// O denominador usa o valor absoluto do ano anterior: sair de −100 para −50 é melhora (+50%), não piora.
    /// @param {ANYVAL} Valor - Valor atual.
    /// @param {ANYVAL} ValorAA - Valor do ano anterior.
    /// @returns (Valor − ValorAA) / |ValorAA|, ou BLANK se um dos dois estiver em branco ou ValorAA = 0.
    FUNCTION Delta.Percentual =
        ( Valor : ANYVAL, ValorAA : ANYVAL ) =>
        IF ( ISBLANK ( Valor ) || ISBLANK ( ValorAA ), BLANK (), DIVIDE ( Valor - ValorAA, ABS ( ValorAA ) ) )

EVALUATE
{ Delta.Percentual ( 120, 100 ), Delta.Percentual ( -50, -100 ) }  // 0,2 · 0,5

DEFINE
    /// Símbolo da variação: ▲ alta, ■ estável, ▼ queda.
    /// @param {ANYVAL} ValorDeltaPercentual - Variação (normalmente o resultado de Delta.Percentual).
    /// @returns "▲", "■", "▼" ou BLANK.
    FUNCTION Delta.Info =
        ( ValorDeltaPercentual : ANYVAL ) =>
        SWITCH (
            TRUE (),
            ISBLANK ( ValorDeltaPercentual ), BLANK (),
            ValorDeltaPercentual > 0, "▲",
            ValorDeltaPercentual = 0, "■",
            "▼"
        )

EVALUATE
{ Delta.Info ( 0.2 ), Delta.Info ( 0 ), Delta.Info ( -0.1 ) }  // ▲ · ■ · ▼

DEFINE
    /// Cor hexadecimal da variação, para formatação condicional por valor do campo.
    /// @param {ANYVAL} ValorDeltaPercentual - Variação (normalmente o resultado de Delta.Percentual).
    /// @returns "#1AAB40" (alta), "#D9B300" (estável), "#D64554" (queda) ou BLANK.
    FUNCTION Delta.Cor =
        ( ValorDeltaPercentual : ANYVAL ) =>
        SWITCH (
            TRUE (),
            ISBLANK ( ValorDeltaPercentual ), BLANK (),
            ValorDeltaPercentual > 0, "#1AAB40",
            ValorDeltaPercentual = 0, "#D9B300",
            "#D64554"
        )

EVALUATE
{ Delta.Cor ( 0.2 ), Delta.Cor ( 0 ), Delta.Cor ( -0.1 ) }

DEFINE
    /// Retorna a descrição da biblioteca Delta (nome, versão, funções e exemplo).
    /// @returns Texto de várias linhas.
    FUNCTION Delta.Sobre =
        () =>
        VAR vLB = UNICHAR ( 10 )
        RETURN
            "📚 Biblioteca: Delta" & vLB
                & "🧑 Autor: Paulo André Jesus" & vLB
                & "🛠️ Versão: 1.1.0" & vLB
                & "📌 Categoria: Comparativos temporais" & vLB & vLB
                & "Funções:" & vLB
                & "• Delta.AA(Valor)" & vLB
                & "• Delta.Absoluto(Valor, ValorAA)" & vLB
                & "• Delta.Percentual(Valor, ValorAA)" & vLB
                & "• Delta.Info(ValorDeltaPercentual)" & vLB
                & "• Delta.Cor(ValorDeltaPercentual)" & vLB & vLB
                & "Exemplo:" & vLB
                & "VAR vAA = Delta.AA([Valor da Venda])" & vLB
                & "RETURN Delta.Percentual([Valor da Venda], vAA)"

EVALUATE
{ Delta.Sobre ( ) }

DEFINE
    /// Converte uma duração (fração de dia) em texto HH:MM:SS, sem limite de 24 horas.
    /// @param {DATETIME} pTimeField - Duração em dias (1 = 24 h), ou um horário.
    /// @returns Texto "HH:MM:SS", ou BLANK.
    FUNCTION Time.TotalTimeToStr =
        ( pTimeField : DATETIME VAL ) =>
        -- Arredonda para segundos inteiros antes de separar horas, minutos e segundos
        VAR vSegundos = ROUND ( pTimeField * 86400, 0 )
        VAR vHoras = INT ( vSegundos / 3600 )
        VAR vMinutos = INT ( MOD ( vSegundos, 3600 ) / 60 )
        VAR vSeg = MOD ( vSegundos, 60 )
        RETURN
            IF (
                ISBLANK ( pTimeField ),
                BLANK (),
                FORMAT ( vHoras, "00" ) & ":" & FORMAT ( vMinutos, "00" ) & ":" & FORMAT ( vSeg, "00" )
            )

EVALUATE
{ Time.TotalTimeToStr ( 1.25 ), Time.TotalTimeToStr ( TIME ( 1, 30, 15 ) ) }  // "30:00:00" · "01:30:15"

DEFINE
    /// Indica se a data cai no sábado ou no domingo.
    /// @param {DATETIME} pDate - Data.
    /// @returns TRUE no sábado e no domingo.
    FUNCTION Date.IsWeekend =
        ( pDate : DATETIME VAL ) =>
        WEEKDAY ( pDate, 2 ) >= 6

EVALUATE
{ Date.IsWeekend ( DATE ( 2025, 9, 27 ) ) }  // TRUE (sábado)

DEFINE
    /// Indica se o ano é bissexto no calendário gregoriano.
    /// @param {INT64} pYearNumber - Ano.
    /// @returns TRUE se o ano for bissexto.
    FUNCTION Date.IsLeapYear =
        ( pYearNumber : INT64 VAL ) =>
        MOD ( pYearNumber, 400 ) = 0
            || ( MOD ( pYearNumber, 4 ) = 0 && MOD ( pYearNumber, 100 ) <> 0 )

EVALUATE
{ Date.IsLeapYear ( 2028 ), Date.IsLeapYear ( 1900 ), Date.IsLeapYear ( 2000 ) }  // TRUE · FALSE · TRUE

DEFINE
    /// Primeiro dia do ano da data.
    /// @param {DATETIME} pDate - Data.
    /// @returns 1º de janeiro do mesmo ano.
    FUNCTION Date.FirstDayOfYear =
        ( pDate : DATETIME VAL ) =>
        DATE ( YEAR ( pDate ), 1, 1 )

EVALUATE
{ Date.FirstDayOfYear ( DATE ( 2026, 9, 25 ) ) }  // 01/01/2026

DEFINE
    /// Último dia do ano da data.
    /// @param {DATETIME} pDate - Data.
    /// @returns 31 de dezembro do mesmo ano.
    FUNCTION Date.LastDayOfYear =
        ( pDate : DATETIME VAL ) =>
        DATE ( YEAR ( pDate ), 12, 31 )

EVALUATE
{ Date.LastDayOfYear ( DATE ( 2026, 9, 25 ) ) }  // 31/12/2026

DEFINE
    /// Número da semana ISO 8601 (semana começa na segunda; semana 1 contém a primeira quinta-feira do ano).
    /// @param {DATETIME} pDate - Data.
    /// @returns Número da semana, de 1 a 53.
    FUNCTION Date.ISOWeekNumber =
        ( pDate : DATETIME VAL ) =>
        -- Quinta-feira da mesma semana decide o ano ISO
        VAR vThursday = pDate - WEEKDAY ( pDate, 2 ) + 4
        RETURN
            INT ( ( vThursday - DATE ( YEAR ( vThursday ), 1, 1 ) ) / 7 ) + 1

EVALUATE
{ Date.ISOWeekNumber ( DATE ( 2025, 1, 5 ) ), Date.ISOWeekNumber ( DATE ( 2027, 1, 1 ) ) }  // 1 · 53

DEFINE
    /// Moda: o valor mais frequente de uma coluna no contexto atual. Empate: o menor valor.
    /// @param {COLUMNREF} pField - Coluna do modelo.
    /// @returns O valor mais frequente, ignorando BLANK.
    FUNCTION Statistics.ModeSingle =
        ( pField : COLUMNREF ) =>
        VAR vFreqByValue =
            ADDCOLUMNS (
                FILTER ( VALUES ( pField ), NOT ISBLANK ( pField ) ),
                "__Freq", CALCULATE ( COUNTROWS ( TABLEOF ( pField ) ) )
            )
        VAR vTop1 = TOPN ( 1, vFreqByValue, [__Freq], DESC, pField, ASC )
        RETURN
            MAXX ( vTop1, pField )

EVALUATE
{ Statistics.ModeSingle ( 'TabDimProduto'[Cor] ) }  // troque por uma coluna do seu modelo

DEFINE
    /// Coeficiente de variação: desvio padrão dividido pela média.
    /// @param {NUMERIC} DesvioPadrao - Desvio padrão.
    /// @param {NUMERIC} Media - Média.
    /// @returns Decimal (0,15 = 15%). BLANK se a média for 0.
    FUNCTION Estatistica.CV =
        ( DesvioPadrao : NUMERIC, Media : NUMERIC ) =>
        DIVIDE ( DesvioPadrao, Media )

EVALUATE
{ Estatistica.CV ( 12, 100 ) }  // 0,12

DEFINE
    /// Interpreta o coeficiente de variação em três faixas.
    /// @param {NUMERIC} CV - Coeficiente de variação em decimal.
    /// @returns Texto com a leitura da faixa, ou BLANK.
    FUNCTION Estatistica.ClassificarCV =
        ( CV : NUMERIC ) =>
        SWITCH (
            TRUE (),
            ISBLANK ( CV ), BLANK (),
            CV <= 0.15, "Dados concentrados, média confiável.",
            CV <= 0.30, "Variação moderada, use com atenção.",
            "A média não representa o grupo. Troque para a mediana."
        )

EVALUATE
{ Estatistica.ClassificarCV ( 0.12 ), Estatistica.ClassificarCV ( 0.4 ) }

DEFINE
    /// Data do Domingo de Páscoa (calendário gregoriano, algoritmo Meeus/Jones/Butcher).
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data da Páscoa, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.EasterDate =
        ( pYearNumber : INT64 VAL ) =>
        VAR vYear = pYearNumber
        VAR vA = MOD ( vYear, 19 )
        VAR vB = QUOTIENT ( vYear, 100 )
        VAR vC = MOD ( vYear, 100 )
        VAR vD = QUOTIENT ( vB, 4 )
        VAR vE = MOD ( vB, 4 )
        VAR vF = QUOTIENT ( vB + 8, 25 )
        VAR vG = QUOTIENT ( vB - vF + 1, 3 )
        VAR vH = MOD ( 19 * vA + vB - vD - vG + 15, 30 )
        VAR vI = QUOTIENT ( vC, 4 )
        VAR vK = MOD ( vC, 4 )
        VAR vL = MOD ( 32 + 2 * vE + 2 * vI - vH - vK, 7 )
        VAR vM = QUOTIENT ( vA + 11 * vH + 22 * vL, 451 )
        VAR vMonth = QUOTIENT ( vH + vL - 7 * vM + 114, 31 )
        VAR vDay = 1 + MOD ( vH + vL - 7 * vM + 114, 31 )
        RETURN
            -- Fora do calendário gregoriano ou do limite de DATE: BLANK, em vez de trocar o ano sem avisar
            IF ( vYear < 1583 || vYear > 9999, BLANK (), DATE ( vYear, vMonth, vDay ) )

EVALUATE
{ Date.Holidays.EasterDate ( 2025 ), Date.Holidays.EasterDate ( 2026 ) }  // 20/04/2025 · 05/04/2026

DEFINE
    /// Data do Domingo de Páscoa (calendário gregoriano, algoritmo Meeus/Jones/Butcher).
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data da Páscoa, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.EasterDate =
        ( pYearNumber : INT64 VAL ) =>
        VAR vYear = pYearNumber
        VAR vA = MOD ( vYear, 19 )
        VAR vB = QUOTIENT ( vYear, 100 )
        VAR vC = MOD ( vYear, 100 )
        VAR vD = QUOTIENT ( vB, 4 )
        VAR vE = MOD ( vB, 4 )
        VAR vF = QUOTIENT ( vB + 8, 25 )
        VAR vG = QUOTIENT ( vB - vF + 1, 3 )
        VAR vH = MOD ( 19 * vA + vB - vD - vG + 15, 30 )
        VAR vI = QUOTIENT ( vC, 4 )
        VAR vK = MOD ( vC, 4 )
        VAR vL = MOD ( 32 + 2 * vE + 2 * vI - vH - vK, 7 )
        VAR vM = QUOTIENT ( vA + 11 * vH + 22 * vL, 451 )
        VAR vMonth = QUOTIENT ( vH + vL - 7 * vM + 114, 31 )
        VAR vDay = 1 + MOD ( vH + vL - 7 * vM + 114, 31 )
        RETURN
            -- Fora do calendário gregoriano ou do limite de DATE: BLANK, em vez de trocar o ano sem avisar
            IF ( vYear < 1583 || vYear > 9999, BLANK (), DATE ( vYear, vMonth, vDay ) )

    /// Terça-feira de Carnaval: 47 dias antes da Páscoa.
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.Carnival =
        ( pYearNumber : INT64 VAL ) =>
        VAR vEaster = Date.Holidays.EasterDate ( pYearNumber )
        RETURN
            -- Terça-feira de Carnaval
            IF ( ISBLANK ( vEaster ), BLANK (), vEaster - 47 )

EVALUATE
{ Date.Holidays.Carnival ( 2025 ), Date.Holidays.Carnival ( 2026 ) }  // 04/03/2025 · 17/02/2026

DEFINE
    /// Data do Domingo de Páscoa (calendário gregoriano, algoritmo Meeus/Jones/Butcher).
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data da Páscoa, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.EasterDate =
        ( pYearNumber : INT64 VAL ) =>
        VAR vYear = pYearNumber
        VAR vA = MOD ( vYear, 19 )
        VAR vB = QUOTIENT ( vYear, 100 )
        VAR vC = MOD ( vYear, 100 )
        VAR vD = QUOTIENT ( vB, 4 )
        VAR vE = MOD ( vB, 4 )
        VAR vF = QUOTIENT ( vB + 8, 25 )
        VAR vG = QUOTIENT ( vB - vF + 1, 3 )
        VAR vH = MOD ( 19 * vA + vB - vD - vG + 15, 30 )
        VAR vI = QUOTIENT ( vC, 4 )
        VAR vK = MOD ( vC, 4 )
        VAR vL = MOD ( 32 + 2 * vE + 2 * vI - vH - vK, 7 )
        VAR vM = QUOTIENT ( vA + 11 * vH + 22 * vL, 451 )
        VAR vMonth = QUOTIENT ( vH + vL - 7 * vM + 114, 31 )
        VAR vDay = 1 + MOD ( vH + vL - 7 * vM + 114, 31 )
        RETURN
            -- Fora do calendário gregoriano ou do limite de DATE: BLANK, em vez de trocar o ano sem avisar
            IF ( vYear < 1583 || vYear > 9999, BLANK (), DATE ( vYear, vMonth, vDay ) )

    /// Sexta-feira da Paixão: 2 dias antes da Páscoa.
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.GoodFriday =
        ( pYearNumber : INT64 VAL ) =>
        VAR vEaster = Date.Holidays.EasterDate ( pYearNumber )
        RETURN
            -- Sexta-feira da Paixão
            IF ( ISBLANK ( vEaster ), BLANK (), vEaster - 2 )

EVALUATE
{ Date.Holidays.GoodFriday ( 2025 ), Date.Holidays.GoodFriday ( 2026 ) }  // 18/04/2025 · 03/04/2026

DEFINE
    /// Data do Domingo de Páscoa (calendário gregoriano, algoritmo Meeus/Jones/Butcher).
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data da Páscoa, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.EasterDate =
        ( pYearNumber : INT64 VAL ) =>
        VAR vYear = pYearNumber
        VAR vA = MOD ( vYear, 19 )
        VAR vB = QUOTIENT ( vYear, 100 )
        VAR vC = MOD ( vYear, 100 )
        VAR vD = QUOTIENT ( vB, 4 )
        VAR vE = MOD ( vB, 4 )
        VAR vF = QUOTIENT ( vB + 8, 25 )
        VAR vG = QUOTIENT ( vB - vF + 1, 3 )
        VAR vH = MOD ( 19 * vA + vB - vD - vG + 15, 30 )
        VAR vI = QUOTIENT ( vC, 4 )
        VAR vK = MOD ( vC, 4 )
        VAR vL = MOD ( 32 + 2 * vE + 2 * vI - vH - vK, 7 )
        VAR vM = QUOTIENT ( vA + 11 * vH + 22 * vL, 451 )
        VAR vMonth = QUOTIENT ( vH + vL - 7 * vM + 114, 31 )
        VAR vDay = 1 + MOD ( vH + vL - 7 * vM + 114, 31 )
        RETURN
            -- Fora do calendário gregoriano ou do limite de DATE: BLANK, em vez de trocar o ano sem avisar
            IF ( vYear < 1583 || vYear > 9999, BLANK (), DATE ( vYear, vMonth, vDay ) )

    /// Corpus Christi: 60 dias depois da Páscoa.
    /// @param {INT64} pYearNumber - Ano, de 1583 a 9999.
    /// @returns Data, ou BLANK fora do intervalo.
    FUNCTION Date.Holidays.CorpusChristi =
        ( pYearNumber : INT64 VAL ) =>
        VAR vEaster = Date.Holidays.EasterDate ( pYearNumber )
        RETURN
            -- Quinta-feira de Corpus Christi
            IF ( ISBLANK ( vEaster ), BLANK (), vEaster + 60 )

EVALUATE
{ Date.Holidays.CorpusChristi ( 2025 ), Date.Holidays.CorpusChristi ( 2026 ) }  // 19/06/2025 · 04/06/2026

DEFINE
    /// Cadeia de formato com escala automática (mil, mi, bi).
    /// Use no formato dinâmico da medida: Formato.Escala ( SELECTEDMEASURE () ).
    /// @param {NUMERIC} valor - Valor que será exibido
    /// @param {INT64} [decimais] - Casas decimais; padrão 1
    /// @returns Cadeia de formato (texto) para a propriedade de formato
    FUNCTION Formato.Escala =
        ( valor : NUMERIC, decimais : INT64 = 1 ) =>
            VAR _abs = ABS ( valor )
            VAR _casas = IF ( decimais > 0, "." & REPT ( "0", decimais ), "" )
            RETURN
                SWITCH (
                    TRUE (),
                    ISBLANK ( valor ), "#,0",
                    ROUND ( _abs / 1000000000, decimais ) >= 1, "#,0,,," & _casas & """ bi""",
                    ROUND ( _abs / 1000000, decimais ) >= 1, "#,0,," & _casas & """ mi""",
                    ROUND ( _abs / 1000, decimais ) >= 1, "#,0," & _casas & """ mil""",
                    "#,0" & _casas
                )

EVALUATE
    ADDCOLUMNS (
        { 950, 12345, 999950, 4567890, 1234567890 },
        "Formato", Formato.Escala ( [Value] ),
        "Exibido", FORMAT ( [Value], Formato.Escala ( [Value] ) )
    )
-- Esperado em modelo pt-BR: 950,0 | 12,3 mil | 1,0 mi | 4,6 mi | 1,2 bi

DEFINE
    /// Testa se um valor está entre dois limites (inclusive), em qualquer ordem.
    /// @param {ANYVAL} pFirstValue - Um dos limites.
    /// @param {ANYVAL} pLastValue - O outro limite.
    /// @param {ANYVAL} pValue - Valor testado.
    /// @returns TRUE se pValue estiver entre os limites.
    FUNCTION Between =
        ( pFirstValue : ANYVAL, pLastValue : ANYVAL, pValue : ANYVAL ) =>
        VAR vMin = MIN ( pFirstValue, pLastValue )
        VAR vMax = MAX ( pFirstValue, pLastValue )
        RETURN
            pValue >= vMin && pValue <= vMax

EVALUATE
{ Between ( 5, 10, 7 ), Between ( 10, 5, 7 ), Between ( DATE ( 2026, 1, 1 ), DATE ( 2026, 3, 31 ), DATE ( 2026, 4, 1 ) ) }  // TRUE · TRUE · FALSE

DEFINE
    /// Completa um número inteiro com zeros à esquerda.
    /// @param {INT64} pNumero - Número. O sinal é descartado.
    /// @param {INT64} pNumeroDeCaracteres - Tamanho final (mínimo 1).
    /// @returns Texto com zeros à esquerda.
    FUNCTION String.FormatWithLeadingZeros =
        ( pNumero : INT64 VAL, pNumeroDeCaracteres : INT64 VAL ) =>
        VAR vNumero = ABS ( pNumero )
        VAR vNumeroDeCaracteres = MAX ( 1, ABS ( pNumeroDeCaracteres ) )
        RETURN
            FORMAT ( vNumero, REPT ( "0", vNumeroDeCaracteres ) )

EVALUATE
{ String.FormatWithLeadingZeros ( 42, 5 ), String.FormatWithLeadingZeros ( -7, 3 ) }  // "00042" · "007"

DEFINE
    /// Avaliação em estrelas: repete um símbolo de 0 a 5 vezes.
    /// @param {INT64} pNumberOfStars - Quantidade de estrelas; abaixo de 0 vira 0, acima de 5 vira 5.
    /// @param {STRING} [pStarChar] - Símbolo. Opcional; padrão "⭐".
    /// @returns Texto com os símbolos repetidos.
    FUNCTION String.FiveStars =
        ( pNumberOfStars : INT64 VAL, pStarChar : STRING VAL = "⭐" ) =>
        VAR vSymbol = IF ( ISBLANK ( pStarChar ), "⭐", pStarChar )
        VAR vNumberOfStars = MIN ( 5, MAX ( 0, pNumberOfStars ) )
        RETURN
            REPT ( vSymbol, vNumberOfStars )

EVALUATE
{ String.FiveStars ( 4 ), String.FiveStars ( 3, "★" ), String.FiveStars ( 9 ) }  // ⭐⭐⭐⭐ · ★★★ · ⭐⭐⭐⭐⭐