Working With MathFlux

1. Overview

Spring Reactive programming has introduced a new age of applications that are both responsive and scalable. Project Reactor is a superior toolkit for managing asynchronous and event-driven programming within this ecosystem.

MathFlux is a component of Project Reactor, which provides us with a variety of mathematical functions designed for reactive programming.

In this tutorial, we’ll explore the MathFlux module from Project Reactor and understand how to utilize it to execute various mathematical operations on reactive streams.

2. Maven Dependency

Let’s create a Spring Boot project in our IDE and add the reactor-core and reactor-extra dependencies to the pom.xml file:

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.6.0</version>
</dependency>

<dependency>
    <groupId>io.projectreactor.addons</groupId>
    <artifactId>reactor-extra</artifactId>
    <version>3.6.0</version>
</dependency>

Additionally, we require the inclusion of reactor-test to effectively test our code:

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-test</artifactId>
    <version>3.6.0</version>
    <scope>test</scope>
</dependency>

3. Using MathFlux‘s Basic Math Functions

Most of the functions in MathFlux require the input of cardinality greater than one and produce an output of cardinality one.

These functions typically accept a Flux as input and return a Mono as output.

The reactor.math package includes a static class named MathFlux, a specialized version of Flux that contains mathematical operators such as max(), min(), sumInt(), and averageDouble().

It’s possible to perform mathematical operations using the MathFlux class by calling its associated methods.

Let’s explore MathFlux basic math functions in detail.

3.1. Sum

The sumInt() method calculates the sum of elements in a Flux of integers. It simplifies adding up numerical values in reactive streams.

We’ll now create a unit test for the method sumInt(). We’ll use StepVerifier for testing our code.

This unit test ensures that the sumInt() method accurately calculates the sum of elements in the given Flux, and validates the correctness of the implementation:

@Test
void givenFluxOfNumbers_whenCalculatingSum_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5);
    Mono<Integer> sumMono = MathFlux.sumInt(numbers);
    StepVerifier.create(sumMono)
      .expectNext(15)
      .verifyComplete();
}

We first create a Flux of integers that represents a dataset. This Flux is then passed as a parameter to the sumInt() method.

3.2. Average

The averageDouble() method calculates the average of elements in a Flux of integers, making it helpful in computing the mean value of an input.

This unit test calculates the average of integers 1 to 5 and compares it to the expected result of 3:

@Test
void givenFluxOfNumbers_whenCalculatingAverage_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5);
    Mono<Double> averageMono = MathFlux.averageDouble(numbers);
    StepVerifier.create(averageMono)
      .expectNext(3.0)
      .verifyComplete();
}

3.3. Min

The min() method determines the smallest value among a Flux of integers.

This unit test is designed to verify the functionality of the min() method:

@Test
void givenFluxOfNumbers_whenFindingMinElement_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(3, 1, 5, 2, 4);
    Mono<Integer> minMono = MathFlux.min(numbers);
    StepVerifier.create(minMono)
      .expectNext(1)
      .verifyComplete();
}

3.4. Max

We can use the max() function from MathFlux to find the highest element. The output is encapsulated in a Mono<Integer> which represents a reactive stream that emits a single Integer result.

This unit test verifies the correct identification of the maximum integer in a Flux:

@Test
void givenFluxOfNumbers_whenFindingMaxElement_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(3, 1, 5, 2, 4);
    Mono<Integer> maxMono = MathFlux.max(numbers);
    StepVerifier.create(maxMono)
      .expectNext(5)
      .verifyComplete();
}

The given Flux in this unit test contains 3, 1, 5, 2, and 4. The purpose of the max() method is to identify the maximum element, which in this case is 5.

4. Conclusion

In this article, we discussed the use of MathFlux in Spring Reactive programming. By utilizing its capabilities, we can simplify complex mathematical tasks within our reactive applications. We saw that MathFlux enables us to seamlessly manage complex data processing, making Spring Reactive applications more intuitive and robust.