Currently, MGDIS has marketed a discrete model of financial multiyear planning. This model, modeled by the software tool SOFI (Sofi, n.d.), allows for the setting out of multiyear financial budgets for public organizations. The mathematical tool based on this model consists of the sequels and series. It is designed to forecast the financial strategy needs. The variables in this discrete modeling cannot be evaluated at any time period. This model uses Excel tables and results outcomes in the form of tables. Each value in the tables is an artificial quantity value over a given period. The model has various disadvantages. The first relates to the fact that the definition of the targeted periods is chosen at the beginning of the process. The second is related to the use of tables. It enforces the calculation of the quantities over the first period of time before calculating them on the second one, etc. The implementation of the model is established by the process that goes on to compute the values of all quantities in the period related to the next one. This means that forecasting in terms of financial strategy is not practical. Hence, this makes the model hard to be used within the strategy elaboration tool depending on the period of time. This modeling allows a less good approximation over a time period. Consequently, this modeling provides less financial information coming from the variables. Therefore, the discrete model is not flexible and is restricted to a finite set of values. It was needed to design an efficient model to be able to respond to a market and strategy needs. We call this model “the continuous-in-time model.”

For instance, coupling two models defined at different periods is not impossible but becomes hard. It is necessary to develop temporal aggregation-redistribution techniques to be able to exchange data between these two models (Kang et al., 2023; Liu et al., 2023; White et al., 2023). A way to surpass those disadvantages is expressed by designing models of a new kind that are continuous-in-time, which contain mathematical objects such as densities and measures and use mathematical tools such as derivation, integration, and convolution. These tools are operators acting on measures over ℝ, named the Radon Measures. Some of these models exist in the literature (Chen et al., 2022; Mondal et al., 2023). With the continuous-in-time approach, the calculations are led without question concerning the period at which financial phenomena will be observed. In particular, the model's results can be reported on any set of periods without reimplementing the model. The key idea consists of using a numerical analysis method, which allows us to choose almost any time period. This modeling shows us how the new framework will be flexible.

Our choice is motivated by the accuracy and the simplicity of the continuous-in-time framework. The mathematical approach to various financial problems has traditionally been through modeling with stochastic process theory (Kao, 2019) and other analytical approaches. These problems concern the combination of modern mathematical and computational finance (Gilli et al., 2019), and solving them has become necessary in the industry. These approaches aim to study market making strategies to profit by earning a good price movement with fewer sources of risk. One of these approaches is solved by the Hamilton-Jacobi-Bellman equation (Obrosova et al., 2022; Dolgov et al., 2023) to achieve objectives and trading strategies (Fang et al., 2022; Wellman, 2022). On the other hand, frameworks that capture realistic features of the financial public could be different from those in financial markets. These frameworks simplify mathematically the computational mechanisms based on classical tools such as derivative, integral, and convolution operators. Another problem arising from the financial sector is to compute these operators efficiently on our modern computers. For instance, the Cuba library is used for multidimensional numerical integration in Hahn (2005). The SOSlib Library, which is a programming package for symbolic and numerical integration of chemical reaction network models, is described in Machné et al. (2006). Finally, authors in Chung and Lee (1994) propose a new family of explicit single-step time integration methods for linear and non-linear structural dynamic analyses. We have tackled computational challenges in previous studies (Chakkour and Frénod, 2016; Chakkour, 2017b, 2019) to build one of these frameworks. These challenges include constructing and improving continuous modeling using the measure theory paradigm (Vernimmen et al., 2022). This framework permits modeling to be carried out closer to reality by lifting periodicity constraints as illustrated in Figure 1. Then, variables can be evaluated at any time period. It also allows a passage from an annual variable to a monthly one, offering natural flexibility with smaller periods such as day and hour.

The layout of this study is structured as follows. Section 2 focuses on the contributions of this study. Section 3 recapitulates the existing discrete mathematical model and how we predict developing the continuous objects. In Section 4, we present various studies related to the continuous framework based on previous theoretical study. Section 5 provides an overview of designing the API with specific goals and constraints. This Section highlights the advanced API mechanisms for building the framework, including time steps and software architecture representing the basis organization of software artifacts. Section 6 covers the implemented methods and objects to demonstrate the computational concept adopted by these mechanisms These implemented algorithms are expressed formally to show the illustrative API purposes. We conclude by summarizing the major points of this study in Section 7.

Scientific computing softwares are always implemented using low-level languages, such as C or Fortran, losing the high-level structure, but some of the well-known softwares for computational finance are developed in C++ and C# in the .NET platform. What is challenging in this study is to implement the framework in form of Application Programming Interface (API). Paticularly, one of the central design philosophies of this API is to allow information to be quickly interchanged without great modifications in coding. The implementation is realized in C#, is considered one of the most widely used programming languages, and leads to integrate this API inside SOFI to produce the continuous software tool (Hickey and Harrigan, 2022; Golmohammadi et al., 2023; Hung et al., 2024). The proposed API applies to partial differential equations arising applications in mathematical finance. This API focuses on using parallelism adopted by Microsoft and provided by Task Parallel Library (TPL). This choice is motivated by parallelism with creating benchmarks for parallel programming (Chakkour, 2022, 2024a,b). The covenient using the API is to facilitate the continuous integration (CI) and connection from this interface with external systems. The modern systems involving continuous integration on different platforms and technologies are described in the literature (Gaston et al., 2009; Lima and Vergilio, 2020). The study of Jackson et al. has adoted this CI environment in Lima and Vergilio (2020) to make the software evolution more rapid and cost-effective. The MOOSE (Gaston et al., 2009) project uses the direct continuous integration between one developed framework and all computational applications to make rapid development of high-quality scientific software.

The main contributions in this study classify the API implementation into two libraries, Lemf (Library Embedded Finance) and LemfAN (Library Embedded Finance And Numerical Analysis). Note that LemfAN is an open-source library; however, Lemf remains confidential, particularly its integration in SOFI. Our own philosophy is to allow these libraries to be quickly interchanged without much code change. Each library contains the collection classes and the interfaces which are partially characterized by their properties. The present study aims to give an overview of this API in detail and its design rationale, including the time complexity of all operations (Bossen et al., 2021; Liu et al., 2021). Finally, we will explain some techniques used in the implementation. The purpose of these libraries is to compute loan, reimbursement, and interest payment schemes.

This short section aims to describe the mathematical objects used in the discrete modeling. These objects involved in the models are sequels and series (Eling and Loperfido, 2020; Marin and Vona, 2023). It means that at an instant n, the state of the modeled system is presented by a large vector U_n, of dimension p. Formally, the financial state at time n+1 is expressed by a recurrence relation which can be written in the following form,

The financial analyses used in this model on contingency tables are within Excel tool. Figure 2 exhibits the data entry in Excel tables and financial trends illustrated in SOFI software. The disadvantages of the discrete models (as described at the beginning of the study) consist in using typical mathematical objects such as sequences and series. Utilizing this approach involves limitations in time and operating redundant objects. Furthermore, there is a restriction to reimplementing the time period at each modeling process. This constraint does not correlate well with the financial reality. In other words, the modeling needs to offer more flexibility with smaller periods. Note that all these objects are exactly of the same nature. Therefore, some objects can be calculated by formulas in the following type,

The first reflection in building the continuous framework to be carried out is establishing the list of new objects that must be manipulated according to their intrinsic nature. Then, choose the appropriate objects having the best representation. For instance, the summation mentioned in relation (Equation 1) can be replaced by integral, and so on. The concept follows this idea even though it is more complicated than that. The complexity is to determine the suitable space in which the model should be built, and these objects can be consistently operated. This complexity will be detailed mathematically in the next section. Then, the financial variables defined in the framework should be represented by measures and fields as depicted in Figure 2. The reason is that generally the notion of measure is an extension of natural concepts of length, surface, and volume. The purpose is to evaluate the amounts given in monetary units corresponding to sums over time period.

There will be considerable potential financial motivation toward creating and implementing the concept of continuous operators. The Excel-based financial module that executes discreet observation modeling is removed to design a computer module that works efficiently without exchanging Excel data. Consequently, the drawbacks of controlling the time period are solved. Through this research study, we will show how implementing integral operators continuously in the targeted space leads to observing the financial risks with tiny periods. However, a direct comparative performance between the discrete modeling and the developed framework will not occur and is outside the scope of this study. The difficulty is accessing SOFI (Excel data). Moreover, an analogy cannot be made simply by comparing them within the same data. In addition, the discrete-parallelization framework appears complicated due to the data structures, programming features, and invoked drawbacks. Fortunately, the computation mechanism is improved within new sophisticated mathematical objects as illustrated in Table 1, and the limitations of the existing models are provided with various explanations. Both frameworks have different modeling paradigms. The expected performances will be naturally expected without direct comparison.

The model building is based on the Radon Measure space ℳ([tI,Θmax]) which is a Banach space over ℝ, supported in [tI,Θmax], when provided with norm:

The Measure space ℳ([tI,Θmax]) is the space dual Cco([tI,Θmax]) of continuous functions defined over [tI,Θmax]. Among ℳ([tI,Θmax]), some measures are absolutely continuous with respect to the Lebesgue measure, and some of them are not. When a given measure m~ is absolutely continuous, this means that it reads m(t)dt, where t is the variable in ℝ, and m(t) is its density, that is, m~=m(t)dt. We have defined in Frénod and Chakkour (2016) the variable measures in which their densities are the amounts expressed in monetary unit. Some of these financial variables built in the model can be described as follows. The first one is the Loan Measure κ˜E. This variable is defined such that the amount borrowed between times t₁ and t₂ is the following amount:

The second one is the Capital Repayment Measure ρ˜K. It is defined such that the amount of capital which is repaid between t₁ and t₂ is the following value:

The Repayment Pattern γ~ manifests in the model the way an amount 1 borrowed at t = 0 is repaid. It means that this Pattern γ~ is a measure with total mass which equals 1, that is:

Loan Measure κ˜E and Capital Repayment Measure ρ˜K are connected by a convolution operator:

Linear operator L is introduced in Chakkour (2017a), and acting on Loan Density κE∈L1([tI,Θmax−Θγ])∩ ​Cc([tI,Θmax−Θγ]), and is defined as follows:

The operator D:L1([tI,Θmax])∩​ Cc([tI,Θmax])→L1([tI,Θmax]) is acting on the Initial Debt Repayment Density ρKI, defined as:

We have discussed the inverting of the operators L and L+D on the space of square-integrable functions defined on a compact (respectively, L~ and L~+D~ when they are extended to radon measure space) in previous studies (Chakkour and Frénod, 2016; Chakkour, 2017b, 2019, 2023). The ill-posedness arising in this framework is examined in these spaces in order to obtain interesting and useful financial solutions and to forecast the budget for future financial plans well.

To emphasize the mathematical aspects of duality and to simplify the notations, the duality bracket will be used to represent the integration of a continuous function with respect to the radon measure over ℝ. In practice, all the building measures are defined on ℝ. In reality, implementing this theory seems to be easy, but the difficulty consists of having continuous piecewise functions that are continuous with superior values in place of continuous functions. For instance, the amounts presented in relations (Equations 2, 3) via integral operator can be presented, respectively, as <κ˜E,𝟙[t1,t2]> and <ρ˜K,𝟙[t1,t2]>.

This section introduces the architectural designs and styles. This also illustrates the development process for describing the API layers. The programming paradigms govern these layers. The application diagram below will show some assembled and configured instances of abstractions that are used to inter-communicate between them. These concrete layers are viewed in terms of the code base to manage and control the instantiation of domain abstractions. Next, abstractions are displayed by compatible ports according to the class diagrams.

This section is devoted to implementing two categories of measures: simple and composed. The explicit integration of some simple measures is provided. The integration of composed measures can be expressed explicitly in terms of the integration of simple ones. The simple measure is a collection of measures such as the constant, affine, quadratic, polynomial, exponential, and Dirac. It can be absolutely continuous with respect to Lebesgue measure λ_Lebesgue or cannot be absolutely continuous with respect to the Lebesgue measure λ_Lebesgue as Dirac measure. For instance, the constant measure is created to borrow uniformly over a time interval. The constant density m_Constant is defined which is equal to a real C independently of variable time t

Since the constant measure m~Constant is absolutely continuous with respect to Lebesgue measure λ_Lebesgue, it can be written in the following form:

The integration of the constant measure m~Constant (defined by relation Equation 32) between inferior bound a and superior bound b returns C × (b−a). The table in Appendix A shows the integration of some simple measures. There are other cathegory of measures, named composed measures that contituting with simple or another composed measure such as sum, product, piecewise, truncated, and convolution. Concerning the sum measure, we would like to compute the sum m of two Dirac measures m₁ and m₂. The sum measure is created to compute the borrowed or paid amount of a sum of two measures over a time interval. They can be interpreted as localized actions at respective positions p₁ and p₂ with amounts M₁ and M₂, that is, m₁ = M₁δ_p1, m₂ = M₂δ_p2. These locations p₁ et p₂ should satisfy,

There are two approaches to compute the integration sum m between a and b. The first one focuses on the fact that points p₁ and p₂ belongs to interval [a, b[. The second one consists of using Chasles relation at point c. Finally, the computation result is the same quantity that is equal to M₁+M₂. The integration of sum m of two measures m₁ et m₂ between inferior bound a and superior bound b returns a sum of two values. The first value is the integration of measure m₁ between inferior bound a and superior bound b. The second value is the integration of measure m₂ between inferior bound a and superior bound b. Algorithm 1 is proposed and implemented to discretize the sum m of two non-discrete measures m₁ and m₂ in low level between inferior bound a and superior bound b is described as follows. It leads to compute the combination of two discrete measures (m1(na+j-1))1≤j≤Nab and (m2(na+j-1))1≤j≤Nab defined on the same universal mesh DAS_TdM as a discrete measures m(n_a+j−1) of Nab values given by following equality:

In what follows, the product measure is built for reasons of nature software production and to enrich the collection measure in the software tool. Figure 12 shows the resulting class diagram from the product measure. The tool is useful to display its data structure as methods and relationships and highlight process from this class. This measure is not used at the moment. In addition, some product operations are prohibited, as the product of two Dirac measures that have no sense in measure theory. The aim here is to express the product of two discrete measures and its integration. Thus, the product of two discrete measures (m1(na+j-1))1≤j≤Nab and (m2(na+j-1))1≤j≤Nab defined on the same universal mesh is discrete measure m(n_a+j−1) of Nab values given by

The integration of discrete measure (m(na+j-1))1≤j≤Nab defined in relation (Equation 35) between inferior bound a and superior bound b is the sum of all values (m(na+j-1))1≤j≤Nab

The consistency of relation (Equation 35) is illustrated by giving an example. This example consists in computing the discrete product of two discrete measures defined on the same universal mesh DAS_TdM. The first discrete measure (m1(na+j-1))1≤j≤Nab is defined by the discretization of constant measure with the constant C₁, between inferior bound x_a and superior bound x_b with discrete step T_dM,

and the second discrete measure (m2(na+j-1))1≤j≤Nab is defined by the discretization of constant measure with the constant C₂, between inferior bound x_a and superior bound x_b with discrete step T_dM

Next, relation (Equation 35) is used for computing discrete product (m(na+j-1))1≤j≤Nab to obtain:

On the other hand, if the constant measure equals to C₁×C₂ is discretized between two points x_a and x_b of universal mesh DAS_TdM, then the same discrete value defined in relation (Equation 39) is obtained. Thus, the consistenty of the expression (Equation 35) is achieved. The integration of product measure at the high level is summarized in Algorithm 2.

To reinforce the financial framework, a piecewise measure is defined by multiple sub-measuress, where each one applies to a different interval. The piecewise measure m~Piecewise that its class diagram shown in Figure 13 is one of the two construction methods defined from,

• a real Fr₀ allowing to generate measures m₀ and m₁, respectively, on intervals ]−∞, Fr₀] and [Fr₀, +∞[. Formally, measure m~Piecewise presented in Figure 14 is a piecewise measure on ℝ, if and only if,

• a subdivision (Fr₀, Fr₁, …, Fr_n) of n+2 intervals allow to generate the measure m_i on each closed interval [Fr_i−1, Fr_i] for i from 1 to n and to generate both measures m₀ and m_n+1, respectively, on the two intervals ]−∞, Fr₀] and [Fr_n, +∞[. Formally, measure m~Piecewise presented in Figure 15 is a piecewise measure on ℝ, if and only if,

Algorithm 3 depicts the integration of piecewise measure m~Piecewise defined in relation (Equation 40).

In order to integrate the piecewise measure m~Piecewise defined in relation (Equation 41) between inferior bound a and superior bound b, the index p and q are defined, respectively, by the indicators for first and last measures of (_{mi)0 ≤ i ≤ n+1} to be integrated. These index p et q are determined by dichotomy search. By considering l∈[[1;n]], index p, q∈[[0;n+1]] are defined using a list of frontiers (F_{ri)0 ≤ i ≤ n} as:

It is necessary to define variables a_⋆ and b_⋆ in order to integrate generally the piecewise measure m~Piecewise. The variable a_⋆ means the superior integration bound of measure m_p. If a<Fr_n, then a_⋆ is equal to the inferior value of Fr_p and b, and if Fr_n ≤ a, then a_⋆ is equal to b. Formally, variable a_⋆ is defined as:

The variable b_⋆ signifies the inferior integration bound of measure m_q. Similary, if Fr₀<b, then b_⋆ is equal to the superior value of Fr_q−1 and of a, and if b ≤ Fr₀, then b_⋆ is equal to a. Formally, variable b_⋆ is defined as:

Moreover, the quantities q₁, q₂, and q₃ are defined as follows. The quantity q₁ is the integration of measure m_p between inferior bound a and superior bound a_⋆,

The quantity q₂ is the sum of integration of measure m_i+1 between inferior bound Fr_i and superior bound Fr_i+1 for i from p to q−2:

The quantity q₃ is the integration of measure m_q between inferior bound b_⋆ and superior bound b:

Algorithm 4 incorporates the integration method of piecewise measure m~Piecewise defined in relation (Equation 41).

Another mathematical measure appended to the API is the truncated measure m~Truncated. Figure 16 illustrates the ability to examine the entities and their relationships in the API from the truncated measure, which is one of the three construction methods defined from

• a subdivision (Fr₀, Fr₁) of three intervals allowing to generate the measure m₁ and null measures m₀ and m₂, respectively, on intervals [Fr₀, Fr₁] and ]−∞, Fr₀], [Fr₁, +∞[. Formally, measure m~Truncated shown in Figure 17 is a truncated measure on ℝ, if and only if,

• a real Fr₀ allowing to generate the null measure m₀ and the measure m₁ on intervals ]−∞, Fr₀] and [Fr₀, +∞[, respectively. In other words, measure m~Truncated illustrated in Figure 18 is a truncated measure on ℝ, if and only if,

• a real Fr₁ allowing to generate the measures m₁ and m₂ on intervals ]−∞, Fr₁] and [Fr₁, +∞[, respectively. In other words, measure m~Truncated presented in Figure 19 is a truncated measure on ℝ, if and only if,

Note that the truncated measure m~Truncated is created for instance to calculate the amount borrowed over a time interval from a truncated and restricted loan over time intervals. Algorithms 5–7 illustrate the integration of this measure defined, respectively, in relations (Equations 48, 49) between inferior bound a and superior bound b.

The tabulated measure is created for three reasons. The first one is to translate an array of values into a discrete measure. The second one is to compute the convolution measure. Finally, the last one is to generate a discrete measure in low level to transfer it to the high level. The aim is to build a tabulated measure m~Tabulated between inferior value V_I and superior bound V_S strictly superior than V_I with a set of n values (_{li)0 ≤ i ≤ n−1}. A tabulation step T_tab is used to share values (_{li)0 ≤ i ≤ n−1} between V_I and V_S, defined by:

The tabulated measure m~Tabulated is a construction method defined from a subdivision (Fr₀, Fr₁, …, Fr_n) given by following frontiers:

permitting to generate the constant density m_j+1 on each closed interval [Fr_j, Fr_j+1] for j from 0 to n−1, and to generate both null densities m₀ and m_n+1, respectively, on intervals ]−∞, Fr₀] and [Fr_n, +∞[.

To integrate the tabulated measure m~Tabulated explicitly between inferior bound a and superior bound b, index p and q given, respectively, in relations (Equations 41, 42) are used. Indeed, the measure m~Tabulated is constituted with null densities m₀ and m_n+1. Algorithm 8 summarizes its implementation.

The discrete convolution is a fundamental operation in the financial model. It is imperative to implement it in order to compute repayment amount with the aid of the Fast Fourier Transform (FFT) method. We refer to articles (Liang et al., 2019; Zlateski et al., 2019) which deal with how FFT can efficiently compute convolution. An algorithm based on convolution theorem stated in Zlateski et al. (2019) was performed using Fourier transforms with much fewer operations. Article Liang et al. (2019) designs its efficient computation with highly optimized FFT implementation.

We have investigated two approaches to compute the discrete convolution. Assuming certain regularity on the proposal measures κ~E and ρ~K. The first approach consists of applying directly the Fourier convolution operator ℱ and its inverse to equality (Equation 5) without change of coordinates, which becomes,

The objective of the second approach is to express the convolution product defined in Equation 5 in term of convolution product of two functions defined on the interval [0, 1]. Assuming that the convex hull of the supported measures κ~E and γ~ are, respectively, intervals [a, b] and [c, d], as presented in Figure 20. Then, the predicted convex hull generated by the class convolution κ~E⋆γ~ is a closed interval contained in [a+c, b+d]. This is read as,

Defining the function κET by the translated function of κ_E, that is, κET(y)=κE(y-c+a), then, the convex hull of the density κET is the interval [c, e], where e = c+(b−a). By making the following change of variable Y = y+c−a, we will obtain,

Defining the functions κE0,1 and γ^{0, 1} by the respective contracted functions of κET and γ on the interval [0, 1]

Next, making the following change of variable z=y-cmax(e,d)-c in the integral operator, we can prove that,

The first approach does not require a change of coordinates. Exploring the second approach remains interesting. A study investigating the comparison of the time computation between these two approaches demonstrated that the first approach is more efficient than the second one. Determining the convex hull of the support from discrete measures is a necessary step in the computed convolution. The next step is to complete these discrete measures by zero such that they have N smallest values, where N is a power of two. Then, the computed vector defined by element-wise multiplication is also requested. Finally, constructing the tabulated measure from this vector and discretizing it is crucial in evaluating the repayment amount.

The field is defined as a continuous function by superior value. Fields are shared in two categories which are simple and composed. The purpose is to provide them definitions and how they are evaluated in high level at point. The discretization of non-discrete fields in low level is based on the evaluation. A simple field can be constant, affine, quadratic, polynomial, exponential, etc. For instance, the constant field is created in order to compute the borrowed amount at a given instant where the loan is a constant function. The constant field F_Constant is defined as the function that is equal to C independently of variable time t,

The evaluation of the constant field F_Constant given by Equation 53 returns constant C. The table in Appendix B summarizes the evaluation of some simple fields. A composed field can be sum, product, piecewise, truncated, or other. The sum field is built to compute the sum of two fields at the instant t. The evaluation of the sum F of two fields F₁ and F₂ in high level at instant t returns a value which is the sum of two values. The first value is the evaluation of field F₁ at time t, and the second value is the evaluation of field F₂ at time t. By the same way the product F of two fields is implemented. They are defined as,

Algorithm 9 is designed for evaluating piecewise field F_Piecewise, defined from a real Fr₀ allowing to generate fields F₀ and F₁, respectively, on intervals ]−∞, Fr₀] and [Fr₀, +∞[. The field F_Piecewise is a piecewise field on ℝ, if and only if,

Algorithm 10 illustrates the evaluation of piecewise field F_Piecewise, determined from a subdivision (Fr₀, Fr₁, …, Fr_n) of n+2 intervals allowing to generate the field F_i on each closed interval [Fr_i−1, Fr_i] for i from 1 to n and to generate both fields F₀ and F_n+1, respectively, on two intervals ]−∞, Fr₀] and [Fr_n, +∞[. The field F_Piecewise is a piecewise field on ℝ, if and only if,

Assuming that truncated field F_Truncated is a construction method defined from a subdivision (Fr₀, Fr₁) of 3 intervals allowing to generate the field F₁ on interval [Fr₀, Fr₁] and to generate both null fields F₀ and F₂, respectively, on intervals ]−∞, Fr₀] and [Fr₁, +∞[. Formally, field F_Truncated is a truncated field on ℝ, if and only if,

Then, Algorithm 11 depicts the evaluation of truncated field F_Truncated given by Equation 54 at instant t.

The purpose here is to present the fast implementation of quadtratic interpolation operator for field F_d that is improved than the linear one. Piecewise-linear functions (Zhang et al., 2021; Goujon et al., 2023) have been used to estimate one-dimensional functions for generations. Then, the restriction of the field F_d is determined at each period interval [y_k, y_k+2[ with three key-value pairs. The field interpolates the values FdD(na+k-1), FdD(na+k), and FdD(na+k+1) in, respectively, points y_k, y_k+1, and y_k+2 for each integer k∈〚1;Nab〛. The set of points y_k follows the definition Equation 10 even for fields. The discrete step T_dF defined for fields plays the same rule of discrete step T_dM for measures. Formally, the field F_d can be written in the following quadratic formula,

In which unknown variables ζ, α, and β are necessary to be determined in terms of discrete step T_dF and values (FdD(na+k-1))1≤k≤Nab+1. This involves establishing the following system,

The equation system given by Equation 55 is reduced to double equations to allow expressing the growth rates FdD(na+k+1)-FdD(na+k) and FdD(na+k)-FdD(na+k-1) in terms of coefficients ζ and α. Formally, the coefficient ζ is determined as,

Since ζ is determined by equality (Equation 56), the growth rate FdD(na+k)-FdD(na+k-1) permits to find out the coefficient α with the following expression,

Finally, to achieve the definition of the field F_d, the estimated coefficient β is obtained by,

After giving a brief detail about evaluating a field, we recall that the Current Debt Field 𝒦_RD is related to Loan Measure κ~E and Repayment Measure ρ~K by the following partial equation:

In which Repayment Measure ρ~K is defined by Equation 5, and measure ρ~KI associated with density ρKI is the Initial Debt Repayment Plan and expresses how current debt amount at the initial time will be repaid. The solution of this ODE (Ordinary Differential Equation) is expressed as,

To evaluate the field 𝒦_RD given by Equation 59 at an instant t, a new method intends to compute the primitive of a measure is implemented. This method is based on numerical approach contained in accumulating a discrete measure to approximate it by a piecewise function. Note that a primitive of measure m_d in low level, null at point x_c is a field F_d. The classical discretization of this object field F_d is defined by discrete field (FdD(na+k-1))1≤k≤Nab+1 given by,

Three situations can be distinguished (x_c<x_a, x_b<x_c, x_a ≤ x_c ≤ x_b) to compute the discrete field (FdD(na+k-1))1≤k≤Nab+1. In all these cases, the discrete field given by equality (Equation 60) can be written as a summation of discrete measure using Chasles relation.

This study presents a comprehensive survey in which measure theory is applied to financial modeling. This theory is needed, in an essential way, to transform the discrete-time framework into the continuous one. In practice, to use the standard tools of this theory, some technical developments based on modern software architecture are imposed. In passing, it is not easy to integrate some fields with respect to some measures to evaluate a variety of capital, investment, and trade received by the organizations. Another aspect of this problem is that conceiving and implementing algorithms in the dual vector space of continuous piecewise function is not suitable. Within the continuous-in-time financial framework, there was a unique API for interacting with the SOFI solver. Making some numerical choices in this space makes sure that the operations between measures and fields will be ensured.

Our purpose was to produce a financial library enabling us to test our ideas and some actions to be maintained. The library should then be simply extendible with respect to frameworks with variable rates set at instants of borrowing or with varying Repayment Patterns. Particularly, high-level interfaces modeling the layers are designed to manage the complex data structures requested by the library components. Further to the implementation, we have created test projects to review implementation results and cover a significant proportion of the code. The layered architecture design allows the implementation of the new functional requirement sets needed for the measure theory paradigm. Another important criterion in the design of the API is consistency. This consistency has proven that at least 96% of errors are not violated of constraints on classes and objects. This performance penalty is taken into account for production computations. Developing a commercial C# that fits the quality requirements achieves a high maintainability API. The implemented framework considers the defined time period of interest only once before setting out the budget project. However, the discrete model has drawbacks in managing it during this period.

We have investigated one preferred way to write multithreaded and parallel API using modern asynchronous methods built on Task. The foundation for our parallelism is based on the TPL library. The future work of this research includes making the parallel API faster and more scalable. It is essential to use parallel abstractions well when distributing the tasks between the available threads. Treating Tasks at a low level and migrating values to a high level is done by a performed mechanism tool, but it requires much analysis and optimization procedures. The data parallelism should be controlled by performing various operations between tasks. For instance, logical task patterns should also be separated from physical threads into hierarch data structures. Another challenge is facilitating locality and parallelism of tasks during intensive computations.

The original contributions presented in the study are included in the article/Supplementary material, further inquiries can be directed to the corresponding author.

TC: Writing – original draft, Writing – review & editing.