Estructura jerárquica del IPC

CPITree

CPITree(base::FullCPIBase, tree::Union{Group, Item}, group_names::Vector{String}, group_codes::Vector{String})
CPITree(; base::FullCPIBase, groupsdf::DataFrame, characters::(NTuple{N, Int} where N), upperlevel_code = "_0", upperlevel_name = "IPC")

Contenedor envolvente de un árbol jerárquico del IPC y los datos necesarios de los gastos básicos para computar cualquier jerarquía dentro del árbol. Permite visualizar y explorar la composición del IPC de un país, así como computar los índices de precios de las diferentes jerarquías de la estructura del IPC. Está compuesto por:

• Un objeto base, de tipo FullCPIBase, el cual almacena las series de tiempo de los índices de los gastos básicos.
• Un objeto tree que contiene la estructura de nodos del IPC.
• El vector de nombres group_names de los grupos del árbol tree.
• El vector de códigos group_codes de los grupos del árbol tree.

El constructor simple requiere una estructura jerárquica de nodos como la devuelta por get_cpi_tree. Al utilizar el constructor con groupsdf y characters, se construye automáticamente un CPITree utilizando los códigos como indicadores de la estructura jerárquica. Los códigos de los gastos básicos contenidos en base describen cómo se agrupan las jerarquías. Por ejemplo, el siguiente FullCPIBase contiene 10 gastos básicos:

julia> base
FullCPIBase{Float32, Float32}: 36 períodos × 10 gastos básicos Jan-01-Dec-03
┌─────┬────────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│ Row │      Dates │ _011101 │ _011201 │ _011202 │ _021101 │ _022101 │ _031101 │ _041101 │ _041201 │ _041202 │ _041301 │
│     │            │  Item A │  Item B │  Item C │  Item D │  Item E │  Item F │  Item G │  Item H │  Item I │  Item J │
│     │            │ 11.8947 │ 2.39931 │ 7.80836 │ 1.58585 │  20.141 │ 12.0526 │ 9.56901 │ 14.6256 │ 15.0276 │ 4.89602 │
├─────┼────────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
│   1 │ 2001-01-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  101.13 │  100.00 │  100.00 │  100.51 │  100.00 │
│   2 │ 2001-02-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  102.28 │  100.00 │  100.00 │  101.02 │  100.00 │
│   3 │ 2001-03-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  103.44 │  100.00 │  100.00 │  101.53 │  100.00 │
│   4 │ 2001-04-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  104.61 │  100.00 │  100.00 │  102.05 │  100.00 │
│   5 │ 2001-05-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  105.79 │  100.00 │  100.00 │  102.56 │  100.00 │
│  ⋮  │     ⋮      │    ⋮    │    ⋮    │    ⋮    │    ⋮    │    ⋮    │    ⋮    │    ⋮    │    ⋮    │    ⋮    │    ⋮    │
│  32 │ 2003-08-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  143.39 │  100.00 │  100.00 │  117.59 │  100.00 │
│  33 │ 2003-09-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  145.02 │  100.00 │  100.00 │  118.19 │  100.00 │
│  34 │ 2003-10-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  146.66 │  100.00 │  100.00 │  118.79 │  100.00 │
│  35 │ 2003-11-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  148.32 │  100.00 │  100.00 │  119.39 │  100.00 │
│  36 │ 2003-12-01 │  100.00 │  100.00 │  100.00 │  100.00 │  100.00 │  150.00 │  100.00 │  100.00 │  120.00 │  100.00 │
└─────┴────────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘
                                                                                                         26 rows omitted

En este ejemplo, el argumento debe especificarse como characters = (3, 4, 5, 7), pues los códigos indican las jerarquías en el IPC de manera siguiente:

• Los primeros 3 caracteres indican la jerarquía de división de gasto.
• El siguiente caracter indica la jerarquía de agrupación de gasto.
• El siguiente caracter indica la jerarquía de subgrupo de gasto.
• Los siguientes 2 caracteres indican el número de gasto básico dentro de su grupo.

Por su parte, el DataFrame groupsdf debe tener la estructura mínima siguiente:

• La primera columna debe ser de tipo String y contiene los códigos de los grupos disponibles en la estructura del IPC.
• La segunda columna debe ser de tipo String y contiene las descripciones o

nombres de los grupos disponibles en la estructura del IPC. Por ejemplo, el DataFrame groupsdf puede verse de esta forma:

17×2 DataFrame
 Row │ code    description 
     │ String  String      
─────┼─────────────────────
   1 │ _01     Div._01
   2 │ _02     Div._02
   3 │ _03     Div._03
   4 │ _04     Div._04
   5 │ _011    Agr._011
   6 │ _021    Agr._021
   7 │ _022    Agr._022
   8 │ _031    Agr._031
   9 │ _041    Agr._041
  10 │ _0111   Subgr._0111
  11 │ _0112   Subgr._0112
  12 │ _0211   Subgr._0211
  13 │ _0221   Subgr._0221
  14 │ _0311   Subgr._0311
  15 │ _0411   Subgr._0411
  16 │ _0412   Subgr._0412
  17 │ _0413   Subgr._0413

Por ejemplo, al construir un CPITree con la estructura de códigos indicada anteriormente y el DataFrame de ejemplo, el árbol del IPC se puede ver de esta forma:

julia> tree = CPITree(; base, groupsdf, characters=(3,4,5,7))
CPITree{Group{Group{Group{Group{Item{Float32}, Float32}, Float32}, Float32}, Float32}} con datos
└─→ FullCPIBase{Float32, Float32}: 36 períodos × 10 gastos básicos Jan-01-Dec-03
_0: IPC [100.0]
├─ _01: Div._01 [21.491905]
│  └─ _011: Agr._011 [21.491905]
│     ├─ _0111: Subgr._0111 [7.352945]
│     │  └─ _011101: Item A [7.352945]
│     └─ _0112: Subgr._0112 [14.13896]
│        ├─ _011201: Item B [6.7442417]
│        └─ _011202: Item C [7.394718]
├─ _02: Div._02 [3.0530455]
│  ├─ _021: Agr._021 [1.1036392]
│  │  └─ _0211: Subgr._0211 [1.1036392]
│  │     └─ _021101: Item D [1.1036392]
│  └─ _022: Agr._022 [1.9494063]
│     └─ _0221: Subgr._0221 [1.9494063]
│        └─ _022101: Item E [1.9494063]
├─ _03: Div._03 [11.68543]
│  └─ _031: Agr._031 [11.68543]
│     └─ _0311: Subgr._0311 [11.68543]
│        └─ _031101: Item F [11.68543]
└─ _04: Div._04 [63.769615]
   └─ _041: Agr._041 [63.769615]
      ├─ _0411: Subgr._0411 [16.103952]
      │  └─ _041101: Item G [16.103952]
      ├─ _0412: Subgr._0412 [28.824577]
      │  ├─ _041201: Item H [11.367162]
      │  └─ _041202: Item I [17.457417]
      └─ _0413: Subgr._0413 [18.841085]
         └─ _041301: Item J [18.841085]

Group{S,T}

Group(code, name, children::Vector{S}) where S
Group(code, name, children...)

Representa un nodo de agrupación de cualquier nivel en la estructura de nodos del IPC. Puede almacenar gastos básicos u otros grupos de mayor jerarquía. Almacena el código del grupo, su nombre o descripción y su ponderación en el IPC.

Posee los campos:

• code: almacena el código del grupo como un String.
• name: almacena el nombre del grupo como un String.
• weight::T: almacena la ponderación del grupo como un valor flotante de tipo T.
• children::Vector{S}: almacena el vector de nodos "hijos" de la estructura. Por ejemplo, este vector podría ser un vector de elementos Item para agrupar un conjunto de gastos básicos.

Aunque este nodo será usualmente creado de manera automática por métodos como CPITree, se pueden crear estructuras jerárquicas manualmente. Por ejemplo, para crear un grupo:

julia> a = Item("_011201", "Item B", 6.7442417f0)
Item{Float32}("_011201", "Item B", 6.7442417f0)

julia> b = Item("_011202", "Item C", 7.394718f0)
Item{Float32}("_011202", "Item C", 7.394718f0)

julia> g = Group("_0112", "Subgr._0112", a, b)
Group{Item{Float32}, Float32}
_0112: Subgr._0112 [14.13896] 
├─ _011201: Item B [6.7442417]
└─ _011202: Item C [7.394718]

Ver también: Item, CPITree.

Item{T}(code::String, name::String, weight::T<:AbstractFloat)

Representa un gasto básico en la estructura de nodos del IPC. Es el nivel más bajo de la estructura. Almacena el código del gasto básico, su nombre o descripción y su ponderación en el IPC. Los datos de este nodo deben estar disponibles en algún FullCPIBase.

Posee los campos:

• code: que almacena el código del gasto básico como un String.
• name: que almacena el nombre del gasto básico como un String.
• weight::T: que almacena la ponderación del gasto básico como un valor flotante de tipo T.

Aunque este nodo será usualmente creado de manera automática por métodos como CPITree, se pueden crear estructuras jerárquicas manualmente. Por ejemplo, para crear un nodo del nivel inferior:

julia> Item("_011101", "Item A", 7.352945f0)
Item{Float32}("_011101", "Item A", 7.352945f0)

Ver también: Group, CPITree.

Base.getindex(cpitree::CPITree, code::AbstractString)

Este método se utiliza para indexar el árbol jerárquico cpitree y obtener una estructura similar cuyo nodo superior sea el nodo con el código provisto code. Por ejemplo, si tenemos el siguiente árbol:

julia> tree
CPITree{Group{Group{Group{Group{Item{Float32}, Float32}, Float32}, Float32}, Float32}} con datos
└─→ FullCPIBase{Float32, Float32}: 36 períodos × 10 gastos básicos Jan-01-Dec-03
_0: IPC [100.0]
├─ _01: Div._01 [21.491905]
│  └─ _011: Agr._011 [21.491905]
│     ├─ _0111: Subgr._0111 [7.352945]
│     │  └─ _011101: Item A [7.352945]
│     └─ _0112: Subgr._0112 [14.13896]
│        ├─ _011201: Item B [6.7442417]
│        └─ _011202: Item C [7.394718]
├─ _02: Div._02 [3.0530455]
│  ├─ _021: Agr._021 [1.1036392] 
│  │  └─ _0211: Subgr._0211 [1.1036392]
│  │     └─ _021101: Item D [1.1036392]
│  └─ _022: Agr._022 [1.9494063]
│     └─ _0221: Subgr._0221 [1.9494063]
│        └─ _022101: Item E [1.9494063]
├─ _03: Div._03 [11.68543]
│  └─ _031: Agr._031 [11.68543]
│     └─ _0311: Subgr._0311 [11.68543]
│        └─ _031101: Item F [11.68543]
└─ _04: Div._04 [63.769615]
   └─ _041: Agr._041 [63.769615]
      ├─ _0411: Subgr._0411 [16.103952]
      │  └─ _041101: Item G [16.103952]
      ├─ _0412: Subgr._0412 [28.824577]
      │  ├─ _041201: Item H [11.367162]
      │  └─ _041202: Item I [17.457417]
      └─ _0413: Subgr._0413 [18.841085]
         └─ _041301: Item J [18.841085]

Al indexar por un código, como _041, obtenemos una estructura similar a partir de ese nodo:

julia> tree["_041"]
CPITree{Group{Group{Item{Float32}, Float32}, Float32}} con datos
└─→ FullCPIBase{Float32, Float32}: 36 períodos × 10 gastos básicos Jan-01-Dec-03
_041: Agr._041 [63.769615]
├─ _0411: Subgr._0411 [16.103952]
│  └─ _041101: Item G [16.103952] 
├─ _0412: Subgr._0412 [28.824577]
│  ├─ _041201: Item H [11.367162]
│  └─ _041202: Item I [17.457417]
└─ _0413: Subgr._0413 [18.841085]
   └─ _041301: Item J [18.841085]

compute_index(cpitree::CPITree [, code::AbstractString])

Permite computar el índice de precios de la jerarquía provista en code. Si se omite code, se computa la jerarquía padre de la estructura cpitree. Si el nodo no se encuentra en el árbol, devuelve nothing.

julia> tree
CPITree{Group{Group{Group{Group{Item{Float32}, Float32}, Float32}, Float32}, Float32}} con datos
└─→ FullCPIBase{Float32, Float32}: 36 períodos × 10 gastos básicos Jan-01-Dec-03
_0: IPC [100.0]
├─ _01: Div._01 [21.491905]
│  └─ _011: Agr._011 [21.491905]
│     ├─ _0111: Subgr._0111 [7.352945]
│     │  └─ _011101: Item A [7.352945]
│     └─ _0112: Subgr._0112 [14.13896]
│        ├─ _011201: Item B [6.7442417]
│        └─ _011202: Item C [7.394718]
├─ _02: Div._02 [3.0530455]
│  ├─ _021: Agr._021 [1.1036392]
│  │  └─ _0211: Subgr._0211 [1.1036392]
│  │     └─ _021101: Item D [1.1036392]
│  └─ _022: Agr._022 [1.9494063]
│     └─ _0221: Subgr._0221 [1.9494063]
│        └─ _022101: Item E [1.9494063]
├─ _03: Div._03 [11.68543]
│  └─ _031: Agr._031 [11.68543]
│     └─ _0311: Subgr._0311 [11.68543]
│        └─ _031101: Item F [11.68543]
└─ _04: Div._04 [63.769615]
   └─ _041: Agr._041 [63.769615]
      ├─ _0411: Subgr._0411 [16.103952]
      │  └─ _041101: Item G [16.103952]
      ├─ _0412: Subgr._0412 [28.824577]
      │  ├─ _041201: Item H [11.367162]
      │  └─ _041202: Item I [17.457417]
      └─ _0413: Subgr._0413 [18.841085]
         └─ _041301: Item J [18.841085]

julia> compute_index(tree, "_041")
36-element Vector{Float32}:
 100.13899
 100.2787
 100.41912
 100.560234
 100.70207
 100.84464
 100.98792
   ⋮
 104.65377
 104.81638
 104.97984
 105.14412
 105.309235
 105.47519

julia> compute_index(tree["_041"])
36-element Vector{Float32}:
 100.13899
 100.2787
 100.41912
 100.560234
 100.70207
 100.84464
 100.98792
   ⋮
 104.65377
 104.81638
 104.97984
 105.14412
 105.309235
 105.47519

julia> a = tree["_041302"]

julia> a === nothing
true

cpi_tree_nodes(codes::Vector{<:AbstractString}; 
    characters::(NTuple{N, Int} where N), depth::Int=1, chars::Int=characters[depth], prefix::AbstractString="", 
    base::FullCPIBase, 
    group_names::Vector{<:AbstractString}, 
    group_codes::Vector{<:AbstractString})

Construye y devuelve una lista de nodos a partir de la lista de códigos codes o de la especificación jerárquica de caracteres en characters. Los nombres y las ponderaciones del nivel inferior (nivel de gasto básico) son obtenidas de la estructura base. Se debe proveer el vector de códigos y nombres de todas las jerarquías superiores en la estructura de códigos en los vectores group_names y group_codes.

Esta función permite crear únicamente la estructura jerárquica de nodos. Para construir de manera automática una estructura del IPC, se recomienda utilizar preferentemente CPITree.

Vea también: CPITree.

get_cpi_tree(; 
    base::FullCPIBase, 
    group_names::Vector{<:AbstractString}, 
    group_codes::Vector{<:AbstractString}, 
    characters::(NTuple{N, Int} where N),
    upperlevel_code = "_0", 
    upperlevel_name = "IPC")

Función superior para obtener estructura jerárquica del IPC. Devuelve el nodo superior del árbol jerárquico. Utiliza la función de más bajo nivel cpi_tree_nodes para construir los nodos del nivel más alto y hacia abajo en la estructura jerárquica. Se debe proveer el vector de códigos y nombres de todas las jerarquías superiores en la estructura de códigos en los vectores group_names y group_codes.

Esta función permite crear únicamente la estructura jerárquica de nodos. Para construir de manera automática una estructura del IPC, se recomienda utilizar preferentemente CPITree.

Vea también: CPITree.