Tutorial: Operador de calculadora de interés compuesto

Important

Esta característica está en versión preliminar pública.

En este tutorial se explica cómo crear un operador UDF de Python para Lakeflow Designer que calcula el interés compuesto. Utilice este ejemplo para aprender los fundamentos de la creación de operadores que transforman valores individuales o columnas. Para más información, consulte Operadores definidos por el usuario en Lakeflow Designer.

Información general

Este tutorial le guiará a través de la creación de un operador definido por el usuario mediante un Python UDF. El operador calcula el valor futuro de una inversión mediante la fórmula de interés compuesta, A = P × (1 + r/n)^(n×t), donde:

• P = Principal (importe inicial)
• r = Tasa de interés anual (como decimal)
• n = Número de períodos compuestos por año
• t = Tiempo en años

Step 1: Escribir y probar la función Python

En primer lugar, defina la función principal de Python que realiza el cálculo. Pruóbelo en una celda del cuaderno para asegurarse de que funciona correctamente.

def compound_amount(principal: float,
                    annual_rate: float,
                    compounds_per_year: int,
                    years: float) -> float:
    """
    Compute compound interest future value.

    A = P * (1 + r/n)^(n*t)

    principal: starting amount (P)
    annual_rate: annual nominal rate as decimal (r), e.g. 0.05
    compounds_per_year: compounding periods per year (n), e.g. 12
    years: time in years (t), can be fractional
    """
    import math
    if principal is None or annual_rate is None or compounds_per_year is None or years is None:
        return None

    if compounds_per_year <= 0:
        raise ValueError("compounds_per_year must be > 0")

    return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                 compounds_per_year * years)

Puede probar la función con el código siguiente:

# $1,000 invested at 5% annual rate, compounded monthly for 10 years
compound_amount(1000, 0.05, 12, 10)
# Expected result: ~1647.01

Paso 2: Creación del código YAML para el operador

La configuración de YAML define cómo aparece el operador en Lakeflow Designer. Para este operador:

• Principal usa un expression widget para que los usuarios seleccionen una columna de sus datos
• Tasa anual, Compuestos por año y Años usan number widgets con valores predeterminados y restricciones
• El operador tiene un puerto de entrada que proporciona datos de columna para el parámetro de expresión.

schema: user-defined-operator-v0.1.0
type: uc-udf
name: Compound Amount
id: finance.compound_amount
version: '1.0.0'
description: >
  Computes the future value of an investment using compound interest.
  Formula: A = P * (1 + r/n)^(n*t)
config:
  type: object
  properties:
    principal:
      type: string
      format: expression
      title: Principal
      examples:
        - 'Select principal column or expression'
      x-ui:
        widget: expression
        port: in
    annual_rate:
      type: number
      title: Annual rate (decimal)
      default: 0.05
      minimum: 0
      examples:
        - 'e.g. 0.05 for 5%'
      x-ui:
        widget: number
    compounds_per_year:
      type: number
      title: Compounds per year
      default: 12
      minimum: 1
      examples:
        - 'e.g. 12 for monthly'
      x-ui:
        widget: number
    years:
      type: number
      title: Years
      default: 10
      minimum: 0
      examples:
        - 'Time in years (t)'
      x-ui:
        widget: number
  required:
    - principal
    - annual_rate
    - compounds_per_year
    - years
  additionalProperties: false
ports:
  input:
    - name: in
      title: Input
  output:
    - name: out
      title: Output

Consulte la referencia de YAML del operador definido por el usuario para obtener una guía exhaustiva de todas las propiedades, tipos de datos, widgets y opciones disponibles.

Paso 3: Crear la función catálogo de Unity

Combine el esquema YAML y la función Python en una sola instrucción CREATE FUNCTION. La configuración de YAML entra en la cadena docstring al principio del cuerpo de la función.

CREATE OR REPLACE FUNCTION main.my_schema.compound_amount(
    principal DOUBLE,
    annual_rate DOUBLE,
    compounds_per_year INT,
    years FLOAT)
RETURNS DOUBLE
LANGUAGE PYTHON
AS $$
  """
  schema: user-defined-operator-v0.1.0
  type: uc-udf
  name: Compound Amount
  id: finance.compound_amount
  version: "1.0.0"
  description: >
    Computes the future value of an investment using compound interest.
    Formula: A = P * (1 + r/n)^(n*t)
  config:
    type: object
    properties:
      principal:
        type: string
        format: expression
        title: Principal
        examples:
          - "Select principal column or expression"
        x-ui:
          widget: expression
          port: in
      annual_rate:
        type: number
        title: Annual rate (decimal)
        default: 0.05
        minimum: 0
        examples:
          - "e.g. 0.05 for 5%"
        x-ui:
          widget: number
      compounds_per_year:
        type: number
        title: Compounds per year
        default: 12
        minimum: 1
        examples:
          - "e.g. 12 for monthly"
        x-ui:
          widget: number
      years:
        type: number
        title: Years
        default: 10
        minimum: 0
        examples:
          - "Time in years (t)"
        x-ui:
          widget: number
    required:
      - principal
      - annual_rate
      - compounds_per_year
      - years
    additionalProperties: false
  ports:
    input:
      - name: in
        title: Input
    output:
      - name: out
        title: Output
  """

  def compound_amount(principal: float,
                      annual_rate: float,
                      compounds_per_year: int,
                      years: float) -> float:
      import math
      if principal is None or annual_rate is None or compounds_per_year is None or years is None:
          return None

      if compounds_per_year <= 0:
          raise ValueError("compounds_per_year must be > 0")

      return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                   compounds_per_year * years)

  return compound_amount(principal, annual_rate, compounds_per_year, years)
$$

Paso 4: Probar la función

Pruebe la función UC directamente con SQL:

-- Test 1: $1,000 at 5% compounded monthly for 10 years
SELECT main.my_schema.compound_amount(1000, 0.05, 12, 10)
-- Expected: ~1647.01

-- Test 2: $1,000 at 5% compounded annually for 1 year
SELECT main.my_schema.compound_amount(1000, 0.05, 1, 1)
-- Expected: 1050.00

-- Test 3: $1,000 at 15% compounded monthly for 1 year
SELECT main.my_schema.compound_amount(1000, 0.15, 12, 1)
-- Expected: ~1160.75

Paso 5: Registrar el operador

Añada el operador a su archivo .user_defined_operators.yaml:

operators:
  - catalog: main
    schema: my_schema
    functionName: compound_amount

Note

Si define este archivo en la carpeta de usuario, solo aparece para usted. Para obtener más información, consulte Hacer que el operador sea reconocible.

Paso 6: Configuración de permisos

Conceda acceso a los usuarios que necesitan usar este operador:

GRANT USE SCHEMA ON SCHEMA main.my_schema TO `<user>`;
GRANT EXECUTE ON FUNCTION main.my_schema.compound_amount TO `<user>`;

Usar el operador en Lakeflow Designer

Una vez registrado, el operador aparecerá en Lakeflow Designer con:

• Lista desplegable para seleccionar la columna principal de los datos de entrada
• Entradas numéricas para velocidad, frecuencia compuesta y años (con valores predeterminados razonables)

Los usuarios pueden aplicar este operador para calcular valores futuros para columnas completas de datos de inversión.