1

ODE NUMERICAL ANALYSIS

Student Name:

Student ID:

Course Name:

Date:

\
 2

Introduction

Generalizing the three-parameter Weibull distribution of the ODE families is an

excellent tool for statistical modeling. The survival processes involved in the various

functions forms in the danger function are predicted using this modeling. Weibull's goodness-

of-fit and inverse Weibull's goodness-of-fit are suitable sub-models to test. This approach can

also be used to combine multiple datasets, which is very useful when filtering the presence of

people (Mahmood et al.,2020). The destiny function of a dataset is unaffected by data models

that have not been modified. Flotation of total time on test (TTT) model transformations are

used to explain the justification of a given dataset. Furthermore, disparities in the recorded

dataset are computed using simulation studies; this work compares the empirical and TTT

datasets.

The ODE Numerical analysis, an extension of the Weibull distribution, has been

suggested for modeling several kinds of failure rate data. By using well-known examples, we

emphasize the importance and superior fitness of scaled empirical and fitted TTT plots to

increasing, cozy bathtub, and unimodal failure rate data (Mahmood et al.,2020). Upper

percentiles of a test statistic assessing goodness-of-fit based on the TTT plot have been

reported for each parameter value in the ODE Numerical analysis. It was investigated how

changing the functional parameter affected the distribution function's overall form, regularity,

and outliers.

This is a crucial part of statistical data modeling because it establishes the expected

lifespan of the item. You may adjust the curve's overall form using the shape parameter. A

threshold characteristic further elaborates on how the distribution shifts, whether for better or

worse (EL-Baset, & Ghazal,2020). A scale parameter is also included, which determines the

percentile's position relative to the cutoff. To mimic industrial processes, not only is Weibull

modeling useful, but lognormal models as well. Furthermore, certain instances shown that the
 3

goodness-of-fit of the ODE Numerical analysis, of which the Weibull and inverse Weibull

are sub-models, may be tested. As a family of ODEs, the Weibull distribution is mirror

images of their inverse transformation.

Bathtub hazard curves have very flat density and middle areas. Parametric modeling

is essential because it allows researchers to learn more about the characteristics of the failure

occurrences and rare hazard functions than they would be able to use a non-parametric

approach. With the advent of the exponential Weibull function, new parameters for defining

curves were available (Mahmood et al.,2020). Probability density, the survival function, and

the hazard parameters all describe the distributions.

When using this modeling approach, it is important to keep an eye on the most

common hazard forms, such as the unimodal and bathtub parameters. Similar dangerous

situations are generated based on the parameters you provide. Focusing on the beta-Weibull

parametric distributions that combine the two-parameter and exponential Weibull

distributions, this article discusses their properties and applications (EL-Baset, &

Ghazal,2020). This approach evaluates the potential for outsized consequences and compares

them to the model's other broad assumptions.

Development of Various types of ODE family distributions

This paper primarily discusses two forms of ODE family distributions. The two-parameter

distribution is the first. This is where you will find the probability density function (PDF)

(pdf). In the traditional two-parameter ODE families of Weibull distribution, the probability

density function is present (pdf)

g1(x;γ,β)=γβ(x/β)

γ−1e−(x/β)

γ,0<x<∞,0<γ,β<∞

The cumulative distributive function (CDF) is as follows:

 4

G1(x;,) = 1 e(x/),

It is possible to estimate monotonically distributed functions using this distribution.

The accelerated failure times can be estimated using this model type. This model is limited

because it does not accept the survival analysis of proportional hazards datasets(EL-Baset, &

Ghazal,2020). The three-parameter extension model is the second form of the ODE families

Weibull model. The survival functions of a given dataset in a distribution determine this.

ODE Weibull hazard Function curve

In the corresponding pdf of the hazard function, the following is the existing quartile function

and

Q ; 0<u<1
(2.8)
The alternative way to derive the above distribution using variable transformations removal

can result in the following curve.

 5

For a simple life distribution, 1/x transformation of the given ODE families does not change

the density it possesses.

ODE Weibull density curve

A four-parameter extension Weibull model is also available. Jeong created this model.

This type of Weibull generalization model incorporates some extra parameter functions into

the three models outlined previously (Mahmood et al.,2020). It is also distinguished by the

distribution's existing survival function. Because it is used to identify diminishing

monotonous functional characteristics, this model is quite thorough.

According to research, integrative probability transformations can be used to

incorporate beta-Weibull distribution families into more prominent families. The use of
 6

probability density functions allows for this (pdf). In this case, the cumulative distribution

function can be used to obtain the third valid function. This allows two-parameter Weibull

functions to be generalized (EL-Baset, & Ghazal,2020). Statistical software available in

stores can be used to run the Weibull statistical distribution. Weibull distributions are a type

of probability distribution.

F(t) = 1 - e-(λt)p

f(t) = pλptp-1e-(λt)p

h(t) = pλptp-1 (power of t)

H(t) = (λt)p

t>0

λ > 0 (scale)

p > 0 (shape)

Parametric inference

To estimate ODE Weibull parameters, standard likelihood procedure is used.this is done by

maximizing the long-likelihood function (l(θ) = lnL(x1,x2,...,xn;α,β,θ)), where x1,x2,...,xn are an

ordered random sample (ie, x1 ≤ x2 ≤ ··· ≤ xn) from the given Numerical analysis. This is given

by;

(3.1)
where

= 0 if jth observation is right censored, j = 1,2,...,n δj

1 else
 7

In the above relations, ODE Weibull is significant in estimating its parameters in two

variable ways. Additionally, it can be proved that the density given is unimodal and is

positively skewed when < 0,β < 0. In this way, it is crucial to avoid some errors involved

when in the computation of the likelihood procedure more when Weibull densities are given

uni-modal.

Good -of-fit

When comparing the goodness-of-fit in ODE Weibull, it is normally difficult to compare a

large dataset of different class alternatives. For this comparison to be effectively executed,

restriction of the alternatives of the ODE Numerical analysis (EL-Baset, & Ghazal,2020).

This is accomplished by using likelihood ratio statistics that are significant in testing the

adequacy of the Weibull inverse sub-models. This is shown by the null hypothesis , H011 : β =

1,H012 : (α = 1, β = 1),H021 : β = 1 and H022 : (α = −1,β = −1). The corresponding likelihood

ratios statistics is

H0ij(i = 1,2;j = 1,2) are:

supR L(α,β,θ)

; i = 1,2; j = 1,2
(3.3)

The R0ij is the restricted parametric space that corresponds to H0ij,i = 1,2; j = 1,2.

In terms of estimates of the likelihood ratio, the following reduced formula emerges;
 8

The TTT Transforms

This method is still reliable in data analysis by engineers even when there are data

deficiencies. In this study, the observed and TTT differences are investigated. Weibull is

crucial in modeling lifetime data (Ishaq & Abiodun,2020). For modeling monotone hazard

rates, negative and positive skewness in parameter densities is required. Weibull is a suitable

modeling method. However, lognormal models and other methods are better for modeling

industrial processes.

Every firm needs data modeling since it gives the management insights into what may

be anticipated from the various risk parameters. It is crucial in the aviation sector to figure

out the airplane maintenance schedule and sensors that are now typical in the Internet of

Things (IoT) technology (Mahmood et al.,2020). Engineers and experts in search engine

optimization must model these processes. The Weibull method for calculating family survival

rates uses incredibly accurate computations. The functional parameters are changed to meet

the studied scenarios, and the changes and results are then recorded for wise decision-

making. Well-known three-parameter ODE families Weibull extensions, such as the

generalized Gamma distribution and exponentiated Numerical analysis, have been

constructed to acquire these behaviors from a single distribution and represent data in the

whole positive real-line. On the other hand, these intriguing Weibull extensions do not help in

modeling significant bathtub-shaped failure rate data, which is common in real-world data

sets.
 9

The above graph is achieved by calculation of asymptomatic variance in a given φF(u)

where (0 < u < 1). We use this approach of ODE Weibull TTT transforms currently to test

goodness-of-fit by use of the TTT plots. The values can be easily checked in any given test

statistics.

Survivor Function in ODE families

Survivor function implies the probability of the event interest has not occurred by the time t.

If T represents the time till death, then S(t) shows the likelihood of survival beyond time t.

def
S(t) = 1 − F(t) = P(T > t) for t > 0.

Development of A 2-parameter Gamma Distribution in ODE Families

This is denoted by G(α,λ) and can reflect a generalized exponential distribution. This

distribution resembles a real-life phenomenon where a survival distribution is nearly Gamma.

Here the functions of the randomized variables assume a gamma distribution.

for t>0

λ > 0 and α > 0 Γ(α) (Parameters)

 10

the respective characteristic function is;

• G(1,λ) = Exp(λ)

• T1 ∼ G(α1,λ), T2 ∼ G(α2,λ), T1 ⊥ T2 =⇒ T1 + T2 ∼ G(α1 + α2,λ)

= integer), then 2λT ∼ χ2k

Used in Simulation Studies

ODE families of distributions can be used to provide insights into simulation statistics. This

is conducted so that random samples of magnitude 100,000 are selected in a given statistical

set of observations. These samples are generated from ODE Weibull families, and Rn values

are obtained. The upper percentage of Rn values is recorded. The procedure is then repeated

in the different parameters and the existing selected values(EL-Baset, & Ghazal,2020). These

parameters of ODE Weibull values are selected in a way to ensure different types of failure

rates. An example of this failure rate is depicted in the below graph on the estimation of the

failure rate of a Mice. 5% of the light solid lines indicate the confident band. At the same

time, the dotted line indicates the empirical data.

Generalization of the Weibull Distribution graph based on TTT

 11

The following graph represents the TTT transforms of the failure rate of a device.

This can be obtained by simulating the device failure rate of the data using a Bathtub-shaped

failure. These simulated data are commonly used to show the ODE families hazard functions

of bathtubs in shapes.

The Gamma graphs developed from the ODE Weibull families

Generalized Gamma Distribution

This is essentially viewed as a generalization of Weibull, exponential, and gamma

distributions, abbreviated as; GG(α,p,λ). Which is defined as;

Where

is a complete gamma function

 12

α > 1

α = 1
h(t)
α < 1

t
The gamma function form reflecting various values of the specified parameter is

shown in the plot as mentioned above. It is an exponential distribution-like constant hazard

function where =1. (Vladimirova et al.,2020). The procedure takes on a concave shape and

increments in the case when it is more significant than one.

 13

Conclusion

ODE Families arise from Weibull distribution and a suitable modeling method.

However, lognormal models and other methods are better for modeling industrial processes.

Every firm needs data modeling since it gives the management insights into what may be

anticipated from the various risk parameters. It is crucial in the aviation sector to figure out

the airplane maintenance schedule and sensors that are now typical in the Internet of Things

(IoT) technology (Mahmood et al.,2020). Engineers and experts in search engine

optimization must model these processes. The Weibull method for calculating family survival

rates uses incredibly accurate computations. The functional parameters are changed to meet

the studied scenarios, and the changes and results are then recorded for wise decision-

making.

Numerous methods can be employed to assess the survival rate of ODE families in

addition to the distribution methods mentioned above. Parameter estimation is one method

for estimating unknown parameters in a data set distribution in NEF. Asymptotic confidence

bounds can also be used to locate unknown NEF parameters. The NFE hypothesis (x) in RH

is built using Renyi entropy (EL-Baset, & Ghazal,2020). It is possible to approximate

monotonously distributed functions using this distribution. Estimating accelerated failure

times can be done using this model type. The limitation of this approach is that proportional

hazards datasets for survival analysis are not supported. The three-parameter extension model

is the second kind of ODE family of a Weibull model (Elgohari & Yousof,2020). the

processes necessary for an organism's survival.

This study examined the impact of the functional parameter on the shape,

organization, and discrepancies of Weibull distribution functions. Since it helps define the

item's surviving lifetime, this is an essential component of statistical data modeling. The

shape parameter represents the curve's shape. Additionally, a threshold attribute describes
 14

how the distribution changes, either adversely or positively (EL-Baset, & Ghazal,2020).

There is a scale parameter as well, which establishes where the percentile stands concerning

the threshold. EveWhileibull modeling is effective. Other modeling methods, including

lognormal models, also work well for simulatedustrial processes.

 15

References

Abd EL-Baset, A. A., & Ghazal, M. G. M. (2020). Exponentiated additive Weibull

distribution. Reliability Engineering & System Safety, 193, 106663.

Basheer, A. M. (2019). Alpha power inverse Weibull distribution with reliability

application. Journal of Taibah University for Science, 13(1), 423-432.

Elgohari, H., & Yousof, H. (2020). The new extension of Weibull distribution: copula,

mathematical properties, and data modeling. Statistics, Optimization & Information

Computing, 8(4), 972-993.

Ishaq, A. I., & Abiodun, A. A. (2020). The Maxwell–Weibull distribution in modeling

lifetime datasets. Annals of Data Science, 7(4), 639-662.

Mahmood, F. H., Resen, A. K., & Khamees, A. B. (2020). Wind characteristic analysis based

on Weibull distribution of Al-Salman site, Iraq. Energy reports, 6, 79-87.

Mazucheli, J., Menezes, A. F. B., & Ghitany, M. E. (2018). The unit-Weibull distribution and

associated inference. J. Appl. Probab. Stat, 13(2), 1-22.

Vladimirova, M., Girard, S., Nguyen, H., & Arbel, J. (2020). Sub‐Weibull distributions:

Generalizing sub‐Gaussian and sub‐Exponential properties to heavier tailed

distributions. Stat, 9(1), e318.
 16

Appendix

ODE.cpp

#include <cstdlib>

#include <algorithm>

#include <iostream>

#include <vector>

#include <numeric>

#include <cmath>

#include "cpp_deSolve.h"

using namespace std;

cpp_deSolve::cpp_deSolve(vector<double> InitialValues

,vector<double> Parameters

,int ModelType)

:_InitialValues(InitialValues)

,_Parameters(Parameters)

,_ModelType(ModelType){

void cpp_deSolve::ModelEquations(double mytime

,vector<double> Compartments

,vector<double>& Derivatives){

Derivatives.clear();

double N = accumulate(Compartments.begin()

,Compartments.end()
 17

,0.0

,plus<double>());

if (_ModelType==1){

double S = Compartments[0];

double I = Compartments[1];

double R = Compartments[2];

double beta = _Parameters[0];

double gamma = _Parameters[1];

Derivatives.push_back(-beta*S*I/N);

Derivatives.push_back(+beta*S*I/N - gamma*I);

Derivatives.push_back(+gamma*I);

}else if (_ModelType==2){

double S = Compartments[0];

double E = Compartments[1];

double I = Compartments[2];

double R = Compartments[3];

double beta = _Parameters[0];

double kappa = _Parameters[1];

double gamma = _Parameters[2];

Derivatives.push_back(-beta*S*I/N);

Derivatives.push_back(-beta*S*I/N);

Derivatives.push_back(+beta*S*I/N-kappa*E);

Derivatives.push_back(+kappa*E-gamma*I);
 18

Derivatives.push_back(+gamma*I);

}else if (_ModelType==3){

double S = Compartments[0];

double I = Compartments[1];

double R = Compartments[2];

double beta0 = _Parameters[0];

double epsilon = _Parameters[1];

double phi = _Parameters[2];

double gamma = _Parameters[3];

double beta = beta0*(1.0+epsilon*cos(2.0*acos(-1.0)*(mytime-phi)/365.25));

Derivatives.push_back(-beta*S*I/N);

Derivatives.push_back(+beta*S*I/N - gamma*I);

Derivatives.push_back(+gamma*I);

}else{

if (Derivatives.size()!=Compartments.size()){

cout << "cpp_deSolve(Compartments): Number of derivatives must match number of

compartments!\n";

cout << " Number of derivatives = " << Derivatives.size() << endl;

cout << " Number of compartments = " << Compartments.size() << endl;

}
 19

void cpp_deSolve::SimulateModel(vector<double> vtime

,vector<vector<double> >& ModelEstimates

){

vector<vector<double> > ModelEstimatesTranspose;

SimulateModel(vtime

,ModelEstimates

,ModelEstimatesTranspose);

void cpp_deSolve::SimulateModel(vector<double> vtime

,vector<vector<double> >& ModelEstimates

,vector<vector<double> >& ModelEstimatesTranspose

){

ModelEstimates.clear();

ModelEstimatesTranspose.clear();

//###################################################################

// calculate the number of new infections per unit time

// for SIR and SEIR models

//###################################################################

double newI;

vector<double> atemp = _InitialValues;

vector<double> oldModelEstimates = _InitialValues;

if (_ModelType==1){ // tack on the number of new infections per unit time beta*S*I/N
 20

double N = accumulate(atemp.begin()

,atemp.end()

,0.0

,plus<double>());

newI = _Parameters[0]*atemp[0]*atemp[1]/N;

if (_ModelType==2){ // tack on the number of new infections per unit time kappa*E

newI = _Parameters[2]*atemp[1];

if (_ModelType<=2) atemp.push_back(newI);

ModelEstimates.push_back(atemp);

for (int i=0;i<atemp.size();i++){

vector<double> btemp;

btemp.push_back(atemp[i]);

ModelEstimatesTranspose.push_back(btemp);

for (int i=1;i<vtime.size();i++){

double delta_t = vtime[i]-vtime[i-1];

vector<double> newModelEstimates;

RungeKuttaSolver(delta_t,vtime[i],oldModelEstimates,newModelEstimates);

oldModelEstimates = newModelEstimates;

vector<double> newModelEstimatesb = newModelEstimates;

 21

if (_ModelType==1){ // tack on the number of new infections per unit time beta*S*I/N

double N = accumulate(newModelEstimates.begin()

,newModelEstimates.end()

,0.0

,plus<double>());

double newI = _Parameters[0]*newModelEstimates[0]*newModelEstimates[1]/N;

newModelEstimatesb.push_back(newI);

if (_ModelType==2){ // tack on the number of new infections per unit time kappa*E

double newI = _Parameters[2]*newModelEstimates[1];

newModelEstimatesb.push_back(newI);

ModelEstimates.push_back(newModelEstimatesb);

for (int j=0;j<newModelEstimatesb.size();j++){

ModelEstimatesTranspose[j].push_back(newModelEstimatesb[j]);

void cpp_deSolve::RungeKuttaSolver(double delta_t

,double mytime

,vector<double> oldModelEstimates

,vector<double>& newModelEstimates){

newModelEstimates.clear();
 22

vector<double> updatedModelEstimates;

vector<double> Derivatives;

vector<double> a1;

ModelEquations(mytime,oldModelEstimates,Derivatives);

for (int i=0;i<oldModelEstimates.size();i++){

a1.push_back(delta_t*Derivatives[i]);

updatedModelEstimates.push_back(oldModelEstimates[i]+delta_t*Derivatives[i]/2.0);

ModelEquations(mytime,updatedModelEstimates,Derivatives);

updatedModelEstimates.clear();

vector<double> a2;

for (int i=0;i<oldModelEstimates.size();i++){

a2.push_back(delta_t*Derivatives[i]);

updatedModelEstimates.push_back(oldModelEstimates[i]+delta_t*Derivatives[i]/2.0);

ModelEquations(mytime,updatedModelEstimates,Derivatives);

updatedModelEstimates.clear();

vector<double> a3;

for (int i=0;i<oldModelEstimates.size();i++){

a3.push_back(delta_t*Derivatives[i]);

updatedModelEstimates.push_back(oldModelEstimates[i]+delta_t*Derivatives[i]);

}
 23

vector<double> a4;

ModelEquations(mytime,updatedModelEstimates,Derivatives);

for (int i=0;i<oldModelEstimates.size();i++){

a4.push_back(delta_t*Derivatives[i]);

for (int i=0;i<oldModelEstimates.size();i++){

newModelEstimates.push_back(oldModelEstimates[i]

+(a1[i]

+2.0*a2[i]

+2.0*a3[i]

+a4[i])/6.0);

if (newModelEstimates[i]<0) newModelEstimates[i] = 0;

cpp_deSolve::~cpp_deSolve(){

cpp_deSolve.h

#include <iostream>

#include <vector>

using namespace std;

 24

class cpp_deSolve{

private:

std::vector<double> _InitialValues;

std::vector<double> _Parameters;

int _ModelType;

void ModelEquations(double mytime

,std::vector<double> ModelEstimates

,std::vector<double>& Derivatives);

void RungeKuttaSolver(double time_step

,double mytime

,std::vector<double> oldModelEstimates

,std::vector<double>& newModelEstimates);

public:

cpp_deSolve(std::vector<double> InitialValues

,std::vector<double> Parameters

,int ModelType);

~cpp_deSolve();

void SimulateModel(std::vector<double> vtime

,std::vector<std::vector<double> >& ModelEstimates

,std::vector<std::vector<double> >& ModelEstimatesTranspose

 25

);

void SimulateModel(std::vector<double> vtime

,std::vector<std::vector<double> >& ModelEstimates

);

};