bool normalizedTime,

bool inverseFunc,

bool subtractInitialIntegral,

double signA,

double signVel,

double signPos,

double scaleVel1,

double scalePos1,

double scalePos2,

Integrator& integral1,

Integrator& integral2,

WaveFormTracer& tracer1,

WaveFormTracer& tracer2,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trA,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trV,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trS,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trVI,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trSI,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trErrV,

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>>& trErrS,

double startTime,

double endTime,

double& a,

double& v,

double& s,

double f_accel,

double f_vel,

double f_pos )

{

double dtime = endTime - startTime;

double dtime_squared = dtime * dtime;

double time_scale_factor = 1.00 / dtime;;

for (double t = startTime; t < (endTime + 0.000001); t = t + 0.0001)

{

if (normalizedTime)

{

double delta_t = (t - startTime);

double tau = delta_t * time_scale_factor;

if (inverseFunc)

{

a = f_accel - signA * pathSegment.getAccel(1.00 - tau);

v = f_vel + signVel * pathSegment.getVelocity(1.00 - tau, scaleVel1 * dtime, subtractInitialIntegral);

s = f_pos - signPos * pathSegment.getPosition(1.00 - tau, scalePos1 * dtime, scalePos2 * dtime_squared, subtractInitialIntegral);

}

else

{

a = signA * pathSegment.getAccel(tau);

v = signVel * pathSegment.getVelocity(tau, scaleVel1 * dtime, subtractInitialIntegral);

s = signPos * pathSegment.getPosition(tau, scalePos1 * dtime, scalePos2 * dtime_squared, subtractInitialIntegral);

}

}

else

{

a = signA * pathSegment.getAccel(t);

v = signVel * pathSegment.getVelocity(t, scaleVel1, subtractInitialIntegral);

s = signPos * pathSegment.getPosition(t, scalePos1, scalePos2, subtractInitialIntegral);

}

trS->set(s);

trA->set(a);

trV->set(v);

double intA = integral1.process(a);

trVI->set(intA);

trSI->set(integral2.process(v));

trErrV->set(trVI->get() - v);

trErrS->set(trSI->get() - s);

tracer1.trace();

tracer2.trace();

}

{

using namespace Math;

using namespace Bezier;

using namespace TrajectoryGeneration;

auto path = std::filesystem::current_path();

std::string strpath = path.generic_string();

StringUtil::remove_substring(strpath, "CntrlLibraryTest");

std::string fileName1 = strpath + "test/TestBezierCurve.dat";

std::string fileName2 = strpath + "test/TestBezierCurve2.dat";

double ts = 0.0001;

WaveFormTracer tracer(fileName1, ts);

EXPECT_TRUE(tracer.open());

WaveFormTracer tracer2(fileName2, ts);

EXPECT_TRUE(tracer2.open());

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trS;

trS.create("x", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>( trS.operator->()) );

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trSI;

trSI.create("SI", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(trSI.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trV;

trV.create("V", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(trV.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trVI;

trVI.create("VI", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(trVI.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trA;

trA.create("A", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(trA.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trErrV;

trErrV.create("ErrV", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(trErrV.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> trErrS;

trErrS.create("ErrV", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(trErrS.operator->()));

double a = 0.00;

double v = 0.00;

double s = 0.00;

double tf = 0.1;

double i_pos = 0.00;

double i_vel = 0.00;

double i_accel = 0.00;

double f_pos = 100.00;

double f_vel = 0.00;

double f_accel = 0.00;

double v_max = 300.00;

double a_max = 600.00;

double j_max = 16000.00;

double travel_distance = f_pos - i_pos;

double Td = 0.00;

double Tv = 0.00;

double Ac = 0.00;

double Dc = 0.00;

double Vc = 0.00;

double sign = 1.00;

if (travel_distance <= 0.00)

{

sign = -1.00;

}

Ac = sign * a_max;

Dc = -sign * a_max;

/*effect of jerk phases*/

double Tjv = abs(Ac / j_max);

double Tjd = abs((Dc - i_accel) / j_max);

/*minimum travel time will never be less then times required for jerk phases (even if all jerk phases do not exist)*/

double tphAp = abs(Ac - i_accel) / j_max; //max. duration of + jerk phase

double tphAm = abs(Ac) / j_max; //max. duration of - jerk phase

double tphDp = abs(Dc) / j_max; //max. duration of + jerk phase for deacceleration

double tphDm = (abs(Dc) - f_accel) / j_max; //max. duration of - jerk phase for deacceleration

//during the jerk phase average acceleration is 50% of max ( for our Bazier sigmoid function )

double aproxJerkDistAp = abs(0.25 * (Ac - i_accel) * tphAp * tphAp);

double aproxJerkDistAm = abs(0.25 * (Ac) * tphAm * tphAm);

double aproxJerkDistDp = abs(0.25 * (Dc - i_accel) * tphDp * tphDp);

double aproxJerkDistDm = abs(0.25 * (abs(Dc) - f_accel) * tphDm * tphDm);

/*during A- and D+ velocity ist nearly Vc (we do not know Vc), but we take max_v*/

aproxJerkDistAp += abs( tphAp * i_vel);

aproxJerkDistAm += abs( tphAm * v_max );

aproxJerkDistDp += abs(tphDp * v_max);

aproxJerkDistDm += abs(tphDm * f_vel);

double aproxJerkDistance = aproxJerkDistAp + aproxJerkDistAm + aproxJerkDistDp + aproxJerkDistDm;

double min_max_vel_distance = abs((v_max * v_max - (i_vel * i_vel)) / (2.00 * a_max)

+ v_max * v_max / (2.00 * a_max));

min_max_vel_distance += aproxJerkDistance;

//the condition for 'triangular profile'

EXPECT_TRUE( abs(travel_distance) < min_max_vel_distance );

Tv = 0.00;

Vc = sign * sqrt((2.00 * a_max * a_max * (travel_distance - aproxJerkDistance) - a_max * i_vel * i_vel) / (a_max + a_max));

//double Ta = abs( (Vc - i_vel) / Ac);

//Td = abs( (Vc-f_vel) / Dc );

/*create 4 Bazier curves:

double P0 = i_accel; //start Acceleration

double P1 = i_accel; //it influence the initial rise phase

double P2 = i_accel; //it shapes the middle part of the curve

double P3 = Ac; //it shapes the middle part of the curve

double P5 = Ac; // it influence the final phase

double P4 = Ac; // it influence the final phase

std::shared_ptr<QuinticBezierCurve> curveAplus = std::make_shared<QuinticBezierCurve>();

curveAplus->setParams(P0, P1, P2, P3, P4, P5);

P0 = Ac; //start Acceleration

P1 = Ac; //it influence the initial phase

P2 = Ac; //it shapes the middle part of the curve

P3 = 0.00; //it shapes the middle part of the curve

P4 = 0.00; // /it influence the final phase

P5 = 0.00; //stop acceleration

std::shared_ptr<QuinticBezierCurve> curveAminus = std::make_shared<QuinticBezierCurve>();

curveAminus->setParams(P0, P1, P2, P3, P4, P5);

//double ConstIntAm0 = curveAminus->firstIntegral(0.00);

PathSegment plusAccelPath;

plusAccelPath.create(0.00, 1.00, 0.00, i_vel, i_pos, curveAplus);

//double ConstIntAp0 = plusAccelPath.getFirstIntegralAtStart();

//it is 100% symmetry ( velocity is 0.5 * a * t, and average acceleration is 0.5 * a

double velocityAp = i_vel + 0.50 * (Ac - i_accel) * tphAp;

double velocityAm = i_vel + 0.50 * (Ac - i_accel) * tphAm;

//double distanceAp = i_vel * tphAp + 0.50 * 0.50 * (Ac - i_accel) * tphAp * tphAp;

double distanceAp = 0.50 * i_accel * tphAp * tphAp + i_vel * tphAp + plusAccelPath.geSecondIntegralAtEnd() * tphAp * tphAp;

//calculate time of constant acceleration to reach Vc

double tphAc = (Vc - (velocityAp + velocityAm)) / Ac;

//velocity part ( velocity is Vc during the whole period)

double velAc = velocityAp + Ac * (tphAc);

double constantI2 = curveAminus->secondIntegral(0.00);

double valAm = constantI2 - curveAminus->secondIntegral(1.0);

double distanceAc = abs(0.50 * Ac * tphAc * tphAc) + (velocityAp) * tphAc;

tphAc += tphAp;

tphAm += tphAc;

Integrator integral;

integral.setParameters(IntegratorMethod::BackwardEuler, 0.0001, 1.00);

integral.setInitialConditions(i_vel);

Integrator integral2;

integral2.setParameters(IntegratorMethod::BackwardEuler, 0.0001, 1.00);

integral2.setInitialConditions(i_pos);

pathFunc(plusAccelPath,

true,

false,

false,

1.00,

1.00,

1.00,

1.00,

1.00,

1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

0.00,

tphAp,

a,

v,

s,

f_accel,

f_vel,

f_pos);

integral.reset();

integral.setInitialConditions(i_vel + velocityAp);

integral2.reset();

integral2.setInitialConditions(i_pos + distanceAp);

/*const acceleration*/

std::shared_ptr<ConstFunction> mathFuncConst = std::make_shared<ConstFunction>(Ac);

PathSegment constAccelPath;

constAccelPath.create(tphAp, tphAc, 0.00, velocityAp, distanceAp, mathFuncConst);

pathFunc(constAccelPath,

false,

false,

false,

1.00,

1.00,

1.00,

1.00,

1.00,

1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

tphAp,

tphAc,

a,

v,

s,

f_accel,

f_vel,

f_pos);

PathSegment minusAccelPath;

minusAccelPath.create(0.00, 1.00, 0.00, velAc, distanceAc + distanceAp, curveAminus);

double distanceAm = distanceAc + distanceAp + Ac * 0.5 * 0.5 * (tphAm - tphAc) * (tphAm - tphAc) + (tphAm - tphAc) * velAc;

//integral.reset();

//integral.setInitialConditions(v);

integral2.reset();

integral2.setInitialConditions(distanceAc + distanceAp);

pathFunc(minusAccelPath,

true,

false,

true,

1.00,

1.00,

1.00,

1.00,

1.00,

1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

tphAc,

tphAm,

a,

v,

s,

f_accel,

f_vel,

f_pos);

integral.reset();

integral.setInitialConditions( velAc + velocityAm);

integral2.reset();

integral2.setInitialConditions( distanceAm);

double deltaD = Dc - f_accel;

//standard d- for path generation

P0 = deltaD;

P1 = deltaD;

P2 = deltaD;

P3 = 0.00;

P4 = 0.00;

P5 = 0.00;

std::shared_ptr<QuinticBezierCurve> funcDminus = std::make_shared<QuinticBezierCurve>();

funcDminus->setParams(P0, P1, P2, P3, P4, P5);

P0 = 0;

P1 = 0;

P2 = 0;

P3 = abs(Dc);

P4 = abs(Dc);

P5 = abs(Dc);

//we can change the angle of view for computations

std::shared_ptr<QuinticBezierCurve> curveDplus = std::make_shared<QuinticBezierCurve>();

curveDplus->setParams(P0, P1, P2, P3, P4, P5);

double ConstIntDp0 = tphDp * curveDplus->firstIntegral(0.00);

P0 = 0.00;

P1 = 0.00;

P2 = 0.00;

P3 = abs(deltaD);

P4 = abs(deltaD);

P5 = abs(deltaD);

std::shared_ptr<QuinticBezierCurve> curveDminus = std::make_shared<QuinticBezierCurve>();

curveDminus->setParams(P0, P1, P2, P3, P4, P5);

double ConstIntDm0 = curveDminus->firstIntegral(0.00);

double velocityDp = (curveDplus->firstIntegral(1.00) - ConstIntDp0) * tphDp;

double velocityDm = (curveDminus->firstIntegral(1.00) - ConstIntDm0) * tphDm;

double posAtStartDp = i_pos + distanceAm;

//calculate distances

double ConstSecIntDp0 = curveDplus->secondIntegral(0.00);

double distanceDp = abs(tphDp * tphDp * (ConstSecIntDp0 - curveDplus->secondIntegral(1.00)));

double velDp = Vc - abs(velocityDp);

//calculate time of constant deacceleration to reach final velocity

double tphDc = abs((Vc - (abs(velocityDp) + abs(velocityDm)) - f_vel) / Dc);

double distanceDc = (velDp)*tphDc - abs(0.50 * Dc * tphDc * tphDc);

distanceDp = Vc * tphDp - distanceDp;

double distanceDm = abs(tphDm * tphDm * (curveDminus->secondIntegral(1.00) - curveDminus->secondIntegral(0.00)) );

double dis = i_pos + distanceAm + distanceDp + distanceDc + distanceDm;

//calculate constant velocity distance

double distToDo = f_pos - dis;

EXPECT_TRUE(distToDo >= 0.00);

double tphVc = abs( distToDo / Vc );

/*const velocity Vc*/

double tAtVc = tphAm + tphVc;

tphDp = tAtVc + tphDp;

tphDc += tphDp;

tphDm += tphDc;

//const velocity

std::shared_ptr<ConstFunction> mathFuncConstVel1 = std::make_shared<ConstFunction>(0.00);

PathSegment constVelPath;

constVelPath.create(tphAm, tAtVc, 0.00, Vc, posAtStartDp, mathFuncConstVel1);

pathFunc(constVelPath,

false,

false,

false,

1.00,

1.00,

1.00,

1.00,

1.00,

1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

tphAm,

tAtVc,

a,

v,

s,

f_accel,

f_vel,

f_pos);

integral.reset();

integral.setInitialConditions(Vc);

integral2.reset();

integral2.setInitialConditions(posAtStartDp + abs(distToDo));

//phase D+

PathSegment deaccelPlusPath;

deaccelPlusPath.create(0.00, 1.00, 0.00, Vc, posAtStartDp + abs(distToDo), curveDminus);

pathFunc(deaccelPlusPath,

true,

false,

true,

-1.00,

1.00,

1.00,

-1.00,

1.00,

-1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

tphAc,

tphAm,

a,

v,

s,

f_accel,

f_vel,

f_pos);

double velocityAtDp = (Vc - abs(velocityDp));

integral.reset();

integral.setInitialConditions(velocityAtDp);

integral2.reset();

integral2.setInitialConditions(posAtStartDp + abs(distToDo) + distanceDp);

//phase Dc (constant deacceleration)

/*const acceleration*/

std::shared_ptr<ConstFunction> mathFuncConstD = std::make_shared<ConstFunction>(deltaD);

PathSegment constDeaccelPath;

constDeaccelPath.create(tphDp, tphDc, 0.00, velocityAtDp, posAtStartDp + abs(distToDo) + distanceDp, mathFuncConstD);

pathFunc(constDeaccelPath,

false,

false,

false,

1.00,

1.00,

1.00,

1.00,

1.00,

1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

tphDp,

tphDc,

a,

v,

s,

f_accel,

f_vel,

f_pos);

integral.reset();

integral.setInitialConditions(velocityDp);

integral2.reset();

integral2.setInitialConditions(posAtStartDp + abs(distToDo) + distanceDp + distanceDc);

//phase D-

double endStartPos = posAtStartDp + abs(distToDo) + distanceDp + distanceDc;

PathSegment deaccelMinusPath;

deaccelMinusPath.create(0.00, 1.00, 0.00, velocityDp, endStartPos, funcDminus);

pathFunc(plusAccelPath,

true,

true,

true,

1.00,

1.00,

1.00,

1.00,

1.00,

1.00,

integral,

integral2,

tracer,

tracer2,

trA,

trV,

trS,

trVI,

trSI,

trErrV,

trErrS,

tphDc,

tphDm,

a,

v,

s,

f_accel,

f_vel,

f_pos);

{

using namespace Math;

using namespace Polynomials;

using namespace TrajectoryGeneration;

auto path = std::filesystem::current_path();

std::string strpath = path.generic_string();

StringUtil::remove_substring(strpath, "CntrlLibraryTest");

std::string fileName1 = strpath + "test/HepticPolynomial.dat";

double ts = 0.001;

WaveFormTracer tracer(fileName1, ts);

EXPECT_TRUE(tracer.open());

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> xt;

xt.create("x", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(xt.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> x1t;

x1t.create("x_der_1", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(x1t.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> x2t;

x2t.create("x_der_2", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(x2t.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> x3t;

x3t.create("x_der_3", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(x3t.operator->()));

double x = 0.00;

double x1 = 0.00;

double x2 = 0.00;

double x3 = 0.00;

double x4 = 0.00;

double tf = 0.1;

double i_pos = 0.00;

double i_vel = 0.00;

double i_accel = 0.00;

double f_pos = 1.10;

double f_vel = 5.00;

double f_accel = 0.00;

double v_max = 300.00;

double a_max = 600.00;

double j_max = 6000.00;

SimplelHepticTrajectory sht(i_pos, f_pos, v_max, a_max, tf);

//double time = sht.calculateMinTime(0.5, 0.5);

tf = 0.5;

//EXPECT_TRUE(time > 0.00001 );

sht.create(0.5);

for (double t = 0.00001; t <= tf; t = t + 0.001)

{

sht.calculateValuesForTime(t, x, x1, x2, x3);

xt->set(x);

x1t->set(x1);

x2t->set(x2);

tracer.trace();

}

{

using namespace Math;

using namespace Polynomials;

HexicPolynomial poly;

auto path = std::filesystem::current_path();

std::string strpath = path.generic_string();

StringUtil::remove_substring(strpath, "CntrlLibraryTest");

std::string fileName1 = strpath + "test/HexicPolynomial.dat";

double ts = 0.001;

WaveFormTracer tracer(fileName1, ts);

EXPECT_TRUE(tracer.open());

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> xt;

xt.create("x", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(xt.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> x1t;

x1t.create("x_der_1", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(x1t.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> x2t;

x2t.create("x_der_2", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(x2t.operator->()));

FlexPointers::FlexibleSharedPtr<Signal<std::double_t>> x3t;

x3t.create("x_der_3", BaseSignal::SignalType::Double);

tracer.addSignal(static_cast<BaseSignal*>(x3t.operator->()));

double x = 0.00;

double x1 = 0.00;

double x2 = 0.00;

double x3 = 0.00;

double x4 = 0.00;

double tf = 1.50;

double a0 = 0.00;

double a1 = 0.00;

double a2 = 0.00;

double a3 = 0.00;

double a4 = 0.00;

double a5 = 0.00;

double a6 = 0.00;

double i_pos = 0.00;

double i_vel = 100.00;

double i_accel = 10.00;

double f_pos = 300.00;

double f_vel = 200.00;

double f_accel = 0.00;

double v_max = 300.00;

double a_max = 600.00;

a0 = i_pos;

a1 = i_vel;;

a2 = i_accel/2.00;

double tau, tau_2, tau_3, tau_4, tau_5, tau_6;

tau = 1.00;

tau_2 = tau * tau;

tau_3 = tau_2 * tau;

tau_4 = tau_3 * tau;

tau_5 = tau_4 * tau;

tau_6 = tau_5 * tau;

double tf_2 = tf * tf;

double tf_3 = tf_2 * tf;

double tf_4 = tf_3 * tf;

double tf_5 = tf_4 * tf;

double tf_6 = tf_5 * tf;

Eigen::Matrix3d A;

A << tau_3, tau_4, tau_5,

4.00 * tau_3, 4.00 * tau_3, 5.00 * tau_4/*, 6.00 * tau_5*/,

6.00 * tau, 12.00 * tau_2, 20.00 * tau_3;/* 30.00 * tau_4*/

//6.00, 24.00 * tau, 60.00 * tau_2;/*, 120.00 * tau_3*/

Eigen::Vector3d b(f_pos - i_pos - i_vel * tau - 0.50 * i_accel * tau * tau,

f_vel - i_vel - i_accel * tau,

f_accel - i_accel);

//(f_pos - i_pos + (i_vel - f_vel ) * tf - (i_accel - f_accel) * tau_5);

Eigen::Vector3d vec_x = A.colPivHouseholderQr().solve(b);

//*delta_s / (tf_4);

a3 = vec_x(0) / tf_3;;

a4 = vec_x(1)/ tf_4;

a5 = vec_x(2)/ tf_5;

a6 = 0.00;

poly.setParams(a0, a1, a2, a3, a4, a5, a6);

for (double t = 0.00001; t <= tf+0.1; t = t + 0.001)

{

poly.calculate(t, x, x1, x2, x3, x4);

xt->set(x);

x1t->set(x1);

x2t->set(x2);

x3t->set(x3);

tracer.trace();

}

{

std::unique_ptr<FuzzyInput> temperature = std::make_unique<FuzzyInput>(-80.00, 80.00, "Temperature");

EXPECT_EQ(-80.00, temperature.get()->getMinimum());

EXPECT_EQ(80.00, temperature.get()->getMaximum());

EXPECT_EQ("Temperature", temperature.get()->getName());

std::unique_ptr<FuzzySet> veryLow = std::make_unique<TrapezoidalIFuzzySetInfL>(-15.0, -3.0, "VeryLow");

std::unique_ptr<FuzzySet> low = std::make_unique<TriangularFuzzySet>(-5.0, 0.0, 18.0, "Low");

EXPECT_EQ(0.58333333333333337, veryLow->getMembership(-10.0));

EXPECT_EQ(1.0, veryLow->getMembership(-60.0));

EXPECT_EQ(0.0, veryLow->getMembership(0.0));

EXPECT_EQ(0.0, low->getMembership(-7.0));

EXPECT_EQ(1.0, low->getMembership(0.0));

EXPECT_EQ(1.0, low->getMembership(0.0));

EXPECT_EQ(0.97777777777777786, low->getMembership(0.4));

{

std::ostringstream ossErrors;

auto p = std::filesystem::current_path();

std::string strpath = p.generic_string();

StringUtil::remove_substring(strpath, "CntrlLibraryTest");

strpath = strpath + "test/test.fis";

FisFileImport fis(strpath);

FuzzyController* controllerFromFis = nullptr;

if (false == fis.readFisFile(ossErrors))

{

std::cout << ossErrors.str();

}

else

{

controllerFromFis = fis.toFuzzyController();

}

EXPECT_EQ(1.0, 1.0);

{

std::ostringstream ossErrors;

auto p = std::filesystem::current_path();

std::string strpath = p.generic_string();

StringUtil::remove_substring(strpath, "CntrlLibraryTest");

std::string fileName1 = strpath + "test/tank.fis";

std::string fileName2 = strpath + "test/tank.txt";

FisFileImport fis(fileName1);

FuzzyController* controllerFromFis = nullptr;

if (false == fis.readFisFile(ossErrors))

{

std::cout << ossErrors.str();

}

else

{

controllerFromFis = fis.toFuzzyController();

}

FuzzyInput* level = controllerFromFis->getInput("level");

FuzzyInput* rate = controllerFromFis->getInput("rate");

FuzzyOutput* valve = controllerFromFis->getOutput();

controllerFromFis->compile();

std::ifstream file(fileName2);

if (!file)

{

ossErrors << "Error opening file " << std::endl;

}