Priority Queue

In a basic queue, elements are appended to the tail and removed from the front, following a first-in, first-out (FIFO) order. This means the first element to arrive is the first to leave. The primary operations of a queue are:

• enqueue: append a new element to the tail of the queue
• dequeue: remove the older element from the head of queue
• peek: query the value of the element located at the head of the queue

In a priority queue, each element has an associated priority level. The priority can be represented as an enumeration (e.g., high, medium, low), an integer (with higher values indicating higher priority), or a real number (e.g., price), among other ordering schemes.

Elements in a priority queue are sorted by priority and time of arrival. When a new element is added, it is positioned behind the last element with the same priority. The element at the head of the queue is the oldest one with the highest priority.

Unlike a basic queue, a priority queue requires a sorting algorithm when inserting a new element. Some implementations may also require a search algorithm to extract the highest-priority element. In the next section, a priority queue is implemented using the insertion sort algorithm for enqueueing new elements.

A Zig's implementation

This section presents a priority queue implementation in Zig, a programming language well-suited for performance-critical applications. Zig’s manual memory management ensures efficient, fine-grained, and predictable allocations. Additionally, its low-latency and cache-efficient data structures make it ideal for real-time applications.

This implementation is based on a generic data type and avoids heap memory allocations. It uses two arrays—one for storing elements and another for storing priorities. These arrays are accessed as a circular list using two indices: head and tail. The enqueue operation runs in \(O(n)\) time, while dequeue and peek execute in \(O(1)\) time.

To provide a generic implementation, a function is defined that takes the type T, an example value of type T, and the queue length as arguments. For example, calling PriorityCircularQueue(u32, 0, 128) defines a queue for unsigned integers with a capacity of 128 elements. Additionally, an error enumeration is included to indicate when the queue is empty or full.

pub const QueueError = error {
    Full,
    Empty,
};

pub fn PriorityCircularQueue(
    T: type,
    example_value: T,
    len: usize
) type {
    return struct {
        ...
    };
}

The attributes of this struct are shown below. It has two arrays: items for storing elements and priorities for storing priority values. The len attribute represents the number of elements in the queue, while size defines the queue's capacity. The queue’s front and rear are represented by head and tail.

struct {
        items: [size]T = [_]T{example_value} ** size,
        priorities: [size]u8 = [_]u8{0} ** size,
        size: usize = size,
        len: usize = 0,
        head: usize = 0,
        tail: usize = size,
        ...
};

To indicate that the queue is empty, a special flag is used with tail == size. If the queue is not empty, tail will have a value between 0 and size - 1, inclusive.

The simplest operation is peek, which only needs to check if the queue is not empty before returning the value at the queue’s head. The dequeue operation is similar to peek, but before returning the value, moves head to the next position. If no more elements remain in the queue, tail is set to size. As mentioned earlier, both operations run in \(O(1)\) time and work the same way in both priority and basic circular queues.

pub fn peek(self: @This()) !T {
    if (self.tail == self.size) {
        return QueueError.Empty;
    }
    return self.items[self.head];
}

pub fn dequeue(self: *@This()) !T {
    if (self.tail == self.size) {
        return QueueError.Empty;
    }
    const curr = self.head;
    self.head = (self.head + 1) % self.size;
    if (self.head == self.tail) {
        // Set the queue as empty
        self.tail = self.size;
    }
    self.len -= 1;
    return self.items[curr];
}

As first action, enqueue appends the new element at the tail of the queue, the same as a basic queue. It also stores the priority of the new element, using the same position as in the items array. However, to be priority queue, the new element has to be moved from the tail if it has a higher priority. It has to be inserted behind the last element with the same priority. Below, the definition of enqueue is presented, except for the sorting operation, that at this moment has been indicated only with a comment.

pub fn enqueue(
    self: *@This(),
    item: T,
    priority: u8
) !void {
    if (self.tail == self.head) {
        return QueueError.Full;                
    }
    if (self.tail == self.size) {
        // The queue is empty, so let's
        // start filling it
        self.tail = self.head;
    }
    self.items[self.tail] = item;
    self.priorities[self.tail] = priority;

    // TODO: Sorting by priority

    self.len += 1;
    self.tail = (self.tail + 1) % self.size;
}

In this example, the insertion sort algorithm is used to maintain the correct order in the priorities array. The first step is to iterate through the queue, starting from the head, to determine the correct position for the new element based on its priority. Once identified, all elements after that position are shifted to make space for the new element. This algorithm has \(O(n)\) execution time. For small queue sizes, this approach may be optimal, but for larger sizes, a more efficient sorting algorithm should be considered.

var curr = self.head;
var move_to = self.tail;

while (curr != self.tail) {
    if (self.priorities[self.tail] > self.priorities[curr]) {
        move_to = curr;
        break;
    }
    curr = (curr + 1) % self.size;
}

while (move_to != self.tail) {
    std.mem.swap(
        T,
        &self.items[self.tail],
        &self.items[move_to]
    );
    std.mem.swap(
        u8,
        &self.priorities[self.tail],
        &self.priorities[move_to]
    );
    move_to = (move_to + 1) % self.size;
}

In summary, this implementation of a priority queue in Zig demonstrates how to efficiently manage prioritized elements using a circular buffer and insertion sort. While this approach provides \(O(1)\) performance for peek and dequeue, the \(O(n)\) complexity of enqueue may become a bottleneck for larger queues. In such cases, more advanced data structures like binary heaps or balanced trees could be considered to optimize performance. Nonetheless, this implementation serves as a solid foundation for real-time applications that require fine-grained control over memory and execution speed.

Source code

A set of related survey items can be like these ones:

1. My claim was attended in a reasonable amount of time.
2. I am satisfied with the timeliness of the service.
3. The time I waited for services was acceptable.
4. I am satisfied with the services I received.

The Cronbach’s Alpha is expressed as a point generally in the interval between 0 and 1. It is asumed that greater values represent a higher internal consistency. As a rule of thumb, obtaining a value higher than 0.7 is an acceptable result. The formula to calculate the Cronbach’s Alpha is shown below.

$$\alpha = \frac{n}{n - 1} (1 - \frac{\sum_{i=1}^n \sigma_i^2}{\sigma_T^2})$$

Where:

\(n\): the number of items
\(\sigma_i^2\): variance in responses for an individual item
\(\sigma_T^2\): variance of total scores for all the items

The reasoning behind the Cronbach's Alpha is that responses for each item should have a lower fluctuation, \(\sigma_i^2\). Instead, the total variance among items \(\sigma_T^2\) should be higher. Therefore, the quotient of the aggregated variance for individual items over the variance of total scores for all the items is expected to be a small number. To obtain the estimation, that number is subtracted from 1 and adjusted by \(\frac{n}{n - 1}\). This final adjustment is to prevent an underestimation when there are few items.

Implementation

A Python's quick implementation can be the next one:

import numpy as np

# Rows are respondents
# Columns are survey items
data = np.array([
    [4.0, 4.0, 4.0, 5.0],
    [3.0, 4.0, 3.0, 4.0],
    [5.0, 4.0, 5.0, 5.0],
    [2.0, 3.0, 2.0, 3.0],
    [4.0, 4.0, 4.0, 4.0],
])

# ddof means degrees of freedom
var_items = np.var(data, axis=0, ddof=1)
total_scores = np.sum(data, axis=1)
var_total = np.var(total_scores, ddof=1)
n = data.shape[0]
correction_factor = n / (n - 1)
alpha = correction_factor * (1 - np.sum(var_items) / var_total)
print(f"Cronbach's Alpha: {alpha:0.4f}")

As an alternative, below, a Rust function is shown as an implementation to calculate the Cronbach's Alpha. It receives as input a matrix where rows are respondents and columns are survey items.

fn cronbach_alpha(data: &Vec<Vec<f64>>) -> f64 {
    let n = data.len() as f64;
    let d = data[0].len();
    // item variances
    let mut var_items = Vec::new();
    for j in 0..d as usize {
        let col: Vec<f64> = data.iter()
            .map(|row| row[j]).collect();
        var_items.push(variance(&col));
    }
    // total score variances
    let total_scores: Vec<f64> = data.iter()
        .map(|row| row.iter().sum()).collect();
    let var_total = variance(&total_scores);
    // cronbach's alpha
    let sum_var_items: f64 = var_items.iter().sum();
    let correction_factor = n / (n - 1.0);
    correction_factor *
        (1.0 - (sum_var_items / var_total))
}

To compute the variance in the previous code, given that \(\sigma^2 = \frac{\sum(x_i - \bar{x})^2}{n - 1}\), one more function can be included:

fn variance(data: &Vec<f64>) -> f64 {
    let n = data.len() as f64;
    let mean = data.iter().sum::<f64>() / n;
    let sqr_diff: f64 = data.iter()
        .map(|x| (x - mean).powi(2)).sum();
    sqr_diff / (n - 1.0)
}

To use these functions, here it is an example:

fn main() {
    // rows are respondents
    // columns are responses to the survey items
    let responses = vec![
        vec![4.0, 4.0, 4.0, 5.0],
        vec![3.0, 4.0, 3.0, 4.0],
        vec![5.0, 4.0, 5.0, 5.0],
        vec![2.0, 3.0, 2.0, 3.0],
        vec![4.0, 4.0, 4.0, 4.0],
    ];
    let alpha = cronbach_alpha(&responses);
    println!("Cronbach's Alpha: {:.4}", alpha);
}

Once that program is compiled and run, the output is like the below one. For this example, a value of 0.8761 indicates that a high internal consistency exists among the included survey items.

$ rustc cronbachalpha.rs
$ ./cronbachalpha 
Cronbach's Alpha: 0.8761

Considerations

On using Cronbatch's Alpha estimations, researchers should attend some considerations, like:

• It is assumed that the set of items is measuring only one dimension. Other estimations, like Factor Analysis, can be used to identify the dimensions of a test.
• An alpha is a property of a set of survey items for a sample of respondents. The alpha should be measured every time the test is administered (Streiner, 2003).
• Alpha increases with the number of items and redundant questions. Therefore, a higher alpha can be the result not only because of the internal consistency, but because of the number of items or the redundancy among them.

Recommended articles

• Sijtsma, K. (2009). On the Use, the Misuse, and the Very Limited Usefulness of Cronbach’s Alpha. Psychometrika, 74(1), 107–120. doi:10.1007/s11336-008-9101-0
• Streiner, D. L. (2003). Starting at the beginning: an introduction to coefficient alpha and internal consistency. Journal of personality assessment, 80(1), 99-103.
• Tavakol, M., & Dennick, R. (2011). Making sense of Cronbach's alpha. International journal of medical education, 2, 53–55. https://doi.org/10.5116/ijme.4dfb.8dfd

Source code

• Python implementation
• Rust implementation

Bond parameters

The basic parameters of a bond are: (a) years to maturity (\(Y\)), (b) principal or face value (\(F\)), which is the amount that is returned to the investor at the end of the period; (c) coupon rate (\(c_r\)) or coupon value (\(CF\)) ; and (d) frequency of payments by year (\(f\)). The coupon value is an amount to be paid to the investor every year until maturity. The relation between coupon value and principal is given by the coupon rate: \(c_r = CF / F\).

To represent a bond in Python, we can use a data class. In this example, we are using the coupon rate as an attribute, instead of the coupon value. Besides that, we are assigning a default value for the payment frequency, to 1.

from dataclasses import dataclass

@dataclass
class Bond:
    principal: float
    cuppon_rate: float
    maturity_years: int
    payment_frequency: int = 1

For example, below a bond is defined with a face value of $1,000, a coupon rate of 5%, 3 years to maturity, and two payments by years.

bond = Bond(
    principal=1000,
    cuppon_rate=0.05,
    maturity_years=3,
    payment_frequency=2,
)

Current price

The decision to invest in a bond can be based on the estimated current price, i.e., how much money in current dollars represent the coupon and principal payments. To produce that estimation, we need a rate of discount (\(r\)), that can be an interest rate in case that current money can be invested in another stake, for example a certificate of deposit in a bank.

The formula to obtain a bond's current price is:

$$P = \sum_{t = 1}^{f \times Y} \frac{C/f}{(1 + \frac{r}{f})^t} + \frac{F}{(1+\frac{r}{f})^Y}$$

The first term is the sum of the current value of the coupon payments. The second term is the current value of the principal. If the frequency of payments by year is 1, that formula is reduced to:

$$P = \sum_{t = 1}^Y \frac{C}{(1 + r)^t} + \frac{F}{(1+r)^Y}$$

Below, it is an implementation of the current price formula as a Python function. When that function is used with the example bond defined above, if a rate of 6% is used, the result is $ 972.91. Given that result, if we have to pay $1,000.00 now to acquire that bond, we might be loosing $27.09.

import numpy as np

def bond_price(bond: Bond, r: float) -> float:
    """
    Computes the current price of a bond at the market rate `r`
    """
    periods = bond.maturity_years * bond.payment_frequency
    cuppon = bond.principal * bond.cuppon_rate
    rate_factor = 1 + r / bond.payment_frequency
    accum = np.sum([
        (cuppon / bond.payment_frequency) / rate_factor ** t
        for t in range(1, periods + 1)
    ])
    accum += bond.principal / rate_factor ** periods
    return accum

Yield to maturity

Another alternative to valuate a bond is, when given a current price, asking what internal rate that bond has. That internal rate is named yield to maturity. It is used to compare one bond acquisition to other investments alternatives based on return rates. In this case, for the previous formulas, we know \(P\) and we want to calculate \(r\).

As a Python function, below is an implementation to find the yield to maturity of a bond given a price. An iterative approximation is used based on the Newton's method. Using the bond_yield function with the example bond previously defined, if we use $972,91 as the price, the result will be 6.0%.

def bond_yield(
    bond: Bond,
    price: float,
    max_iter = 100,
    tolerance = 1e-5
) -> float:
    periods = bond.maturity_years * bond.payment_frequency
    cuppon = bond.principal * bond.cuppon_rate
    bond_yield = 0.01
    iterations = 0
    while iterations < max_iter:
        yield_price = bond_price(bond, bond_yield)
        diff = yield_price - price
        if abs(diff) < tolerance:
            break
        bond_yield += diff / price * 0.1
        iterations += 1
    return bond_yield

Interest rate and price

Finally, it is important to understand the relation between the interest rate and the price of a bond. If the interest rate goes up, the price goes down. If the interest rate goes down, the price goes up. The relation is convex and inverse, as it is shown in the below figure. In different words, if the interest rate goes up, instead of putting money in a bond, we will be motivated to invest on another alternative with higher return.

import matplotlib.pyplot as plt

def plot_bond_price(bond: Bond, x: np.ndarray, y: np.ndarray):
    plt.plot(x * 100, y / bond.principal * 100, color="g")
    plt.axhline(y=100, color="r", label="Face value")
    plt.ylabel("Price (%)")
    plt.xlabel("Yield (%)")
    plt.legend()

x = np.linspace(0.01, 1.0, 100)
y = np.vectorize(lambda r: bond_price(bond, r))(x)
plot_bond_price(bond, x, y)