In 1965 L.A. Zadeh extended crisp logic to fuzzy logic also crisp sets to fuzzy sets allowing element  to take partial degree of membership to the set  and this membership is noted by , so the nonmembership degree of the same element to the set  is  [1]. In 1986 K. Atanassov extended fuzzy logic and fuzzy sets to intuitionistic fuzzy logic and intuitionistic fuzzy sets letting space to indeterminacy between membership and nonmembership degrees by assuming that  where  [2]. In 1995 F. Smarandache extended boths of the previous logics to neutrosophic logic and introduced neutrosophic sets by defining three not  necessarily  dependent components; membership, nonmembership, and indeterminacy degrees. So element  of the set  are described by the triplet (  where . In applied sciences nonstandard analysis is not useful, so the last definition was transformed into standard analysis describing elements by the same triplet but  introducing what is known by single valued neutrosopihc sets [3], [4].

Neutrosophy had been applied in many fields of science including abstract algebra, topology, probability, statistics, machine learning, decision making, number theory, operations research, engineering, control systems, etc [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15].

2. Definitions   

2.1. Trapezoidal Neutrosophic Number

Trapezoidal neutrosophic number  defined on the set of real numbers  by its membership, indeterminacy and nonmembership functions: [16]

2.2. -Cuts of Trapezoidal Neutrosophic Number

Let   be a single-valued trapezoidal neutrosophic number, the crisp subset of reals defined by: [16]

Is called -cuts of of  where  and .

2.3. Arithemetic Operations on Single-Valued Trapezoidal Neutrosophic Numbers Based on -Cuts

First lets remember arithmetic operations on two real valued intervals  which are defined as follows:

Where:

Now let  be two single-valued trapezoidal neutrosophic numbers with -cuts as follows: [16]

Then arithmetic operations on  can be defiend as follows:

Where * is one of the operations {-,+,×,÷} and can be done using same interval arithmetic rules.

2.4. Value and Ambiguity Index Based Rnking Methods [16]

Value of single-valued trapezoidal neutrosophic number  can be defined as follows:

Also ambiguity of  can be defined as follows:

Then value index and ambiguity index can be defined as follows:

Where the values of  are determined by the decision maker preferences according to the condition 

Now two single-valued trapezoidal neutrosophic numbers  can be ranked by the following algorithm:

1.     if  then 

2.     if  then 

3.     if  then

a.      if  then 

b.     if  then 

c.      if  then 

3. Neutrosophic Maple Package

Now we introduce for the first time a Maple package that saves lots of time spended on doing operations on single-valued trapezoidal neutrispohic numbers and explain it by examples.

interface(warnlevel = 0):
Neutrosophic:=module()
description "using this module you can sum, subtract, divide and multiply trapezoidal neutrosophic numbers based on their alpha-beta-gamma cuts"; 
option package;
export NeutrosophicNumber,NeutrosophicAlphaBetaGammaCuts,PlotNeutrosophicNumber, NeutrosophicSum,NeutrosophicSub,NeutrosophicMult,NeutrosophicDiv,NeutrosophicValue, NeutrosophicAmbiguity,ValueIndex,AmbiguityIndex,CompareNeutrosophicNumbers;

#Neutrosophic Numbers

#Define a Trapezoidal Neutrosophic Number:

Neutrosophic Number:= proc (t1, t2, t3, t4, i1, i2, i3, i4, f1, f2, f3, f4)
 return ([[t1, t2, t3, t4], [i1, i2, i3, i4], [f1, f2, f3, f4]])
 end proc;

#Neutrosophic Alpha,Beta,Gamma Cuts:
NeutrosophicAlphaCuts := proc (a::list)
local alpha := 'alpha'
local leftT:= ;
local rightT:= ;
return [leftT,rightT]
end proc;

NeutrosophicBetaCuts := proc (b::list)
local beta:= 'beta'
local leftI:= ;
local rightI:= ;
return [leftI,rightI]
end proc;

NeutrosophicGammaCuts := proc (c::list)
local gamma:= ' gamma '
local leftG:= ;
local rightG:= ;
return [leftG,rightG]
end proc;

NeutrosophicAlphaBetaGammaCuts := proc (n::list)
return ([NeutrosophicAlphaCuts(n[1]), NeutrosophicBetaCuts(n[2]), NeutrosophicGammaCuts(n[3])])
end proc;

#Determine whether we have Neutrosophic Cuts or NOT:

IsNeutrosophicCuts := proc (x::list)
if numelems(x[1]) = 2 then return true else return false end if 
end proc;

# Plotting Neutrosophic Numbers:
PlotNeutrosophicAlphaCuts:= proc(f1::list)
local Left:=unapply(expand(f1[1](alpha)),alpha);
local Right:=unapply(expand(f1[2](alpha)),alpha);
local L := Vector(11, unapply(Left((alpha-1)*(1/10)), alpha));
localU := Vector(11, unapply(Right((alpha-1)*(1/10)), alpha));
local alpha:=Vector([0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1]);
F1:=dataplot( L,alpha,color="Green",style=line); G1:=dataplot(U,alpha,color="Green",style=line); H1:=dataplot(L[11]..U[11],Vector(11,1),color="Green",style=line,legend="Truth", legendstyle=[font=["HELVETICA",9],location=right]);
return {F1,G1,H1};
end proc;

PlotNeutrosophicBetaCuts := proc (f2::list)
local Left := unapply(expand(f2[1](beta)), beta);
local Right := unapply(expand(f2[2](beta)), beta);
local L := Vector(11, unapply(Left((beta-1)*(1/10)), beta)); 
local U := Vector(11, unapply(Right((beta-1)*(1/10)), beta));
local beta := Vector([0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
F1 := dataplot(L, beta, color = "Blue", style = line);
G1 := dataplot(U, beta, color = "Blue", style = line);
H1 := dataplot(L[1] .. U[1], Vector(11, 0), color = "Blue", style = line, legend = "Indeterminacy", legendstyle = [font = ["HELVETICA", 9], location = right]);
return {F1, G1, H1};
end proc;

PlotNeutrosophicGammaCuts := proc (f3::list)
local Left:= unapply(expand(f3[1](gamma)), gamma);
local Right := unapply(expand(f3[2](gamma)), gamma);
local L := Vector(11, unapply(Left((gamma-1)*(1/10)), gamma));
local U := Vector(11, unapply(Right((gamma-1)*(1/10)), gamma));
local gamma := Vector([0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
F1 := dataplot(L, gamma, color = "Red", style = line);
 G1 := dataplot(U, gamma, color = "Red", style = line);
 H1 := dataplot(L[1] .. U[1], Vector(11, 0), color = "Red", style = line, legend = "Falsity", legendstyle = [font = ["HELVETICA", 9], location = right]);
return {F1, G1, H1};
end proc;

PlotNeutrosophicNumber := proc (n::list)
if not IsNeutrosophicCuts(n) then 
t := PlotNeutrosophicAlphaCuts(NeutrosophicAlphaCuts(n[1])):
i := PlotNeutrosophicBetaCuts(NeutrosophicBetaCuts(n[2])):
f := PlotNeutrosophicGammaCuts(NeutrosophicGammaCuts(n[3])):
else
t := PlotNeutrosophicAlphaCuts(n[1]):
i := PlotNeutrosophicBetaCuts(n[2]):
f := PlotNeutrosophicGammaCuts(n[3]):
end if; 
plots:-display(t, i, f);
end proc;

#Neutrosophic Arithmetic Operations:
NeutrosophicSum := proc (t1::list, t2::list)
x := t1: y := t2:
if not IsNeutrosophicCuts(t1) then x := NeutrosophicAlphaBetaGammaCuts(t1); end if;
if not IsNeutrosophicCuts(t2) then y := NeutrosophicAlphaBetaGammaCuts(t2); end if;
L1 := unapply(x[1][1](alpha)+y[1][1](alpha), alpha);
U1 := unapply(x[1][2](alpha)+y[1][2](alpha), alpha);
L2 := unapply(x[2][1](beta)+y[2][1](beta), beta);
U2 := unapply(x[2][2](beta)+y[2][2](beta), beta);
L3 := unapply(x[3][1](gamma)+y[3][1](gamma), gamma); 
U3 := unapply(x[3][2](gamma)+y[3][2](gamma), gamma); 
[[L1, U1], [L2, U2], [L3, U3]]
end proc;

NeutrosophicMult := proc (t1::list, t2::list)
x := t1: y := t2:
if not IsNeutrosophicCuts(t1) then x := NeutrosophicAlphaBetaGammaCuts(t1); end if;
if not IsNeutrosophicCuts(t2) then y := NeutrosophicAlphaBetaGammaCuts(t2); end if;
L1 := unapply(x[1][1](alpha)*y[1][1](alpha), alpha);
U1 := unapply(x[1][2](alpha)*y[1][2](alpha), alpha);
L2 := unapply(x[2][1](beta)*y[2][1](beta), beta);
U2 := unapply(x[2][2](beta)*y[2][2](beta), beta);
L3 := unapply(x[3][1](gamma)*y[3][1](gamma), gamma);
U3 := unapply(x[3][2](gamma)*y[3][2](gamma), gamma);
[[L1, U1], [L2, U2], [L3, U3]]
end proc;

NeutrosophicSub := proc (t1::list, t2::list)
x := t1: y := t2:
if not IsNeutrosophicCuts(t1) then x := NeutrosophicAlphaBetaGammaCuts(t1); end if;
if not IsNeutrosophicCuts(t2) then y := NeutrosophicAlphaBetaGammaCuts(t2); end if;
L1 := unapply(x[1][1](alpha)-y[1][2](alpha), alpha);
U1 := unapply(x[1][2](alpha)-y[1][1](alpha), alpha);
L2 := unapply(x[2][1](beta)-y[2][2](beta), beta);
U2 := unapply(x[2][2](beta)-y[2][1](beta), beta);
L3 := unapply(x[3][1](gamma)-y[3][2](gamma), gamma);
U3 := unapply(x[3][2](gamma)-y[3][1](gamma), gamma);
[[L1, U1], [L2, U2], [L3, U3]]
end proc;

NeutrosophicDiv := proc (t1::list, t2::list)
x := t1: y := t2:
if not IsNeutrosophicCuts(t1) then x := NeutrosophicAlphaBetaGammaCuts(t1); end if;
if not IsNeutrosophicCuts(t2) then y := NeutrosophicAlphaBetaGammaCuts(t2); end if;
L1 := unapply(x[1][1](alpha)/y[1][2](alpha), alpha);
U1 := unapply(x[1][2](alpha)/y[1][1](alpha), alpha);
L2 := unapply(x[2][1](beta)/y[2][2](beta), beta);
U2 := unapply(x[2][2](beta)/y[2][1](beta), beta);
L3 := unapply(x[3][1](gamma)/y[3][2](gamma), gamma);
U3 := unapply(x[3][2](gamma)/y[3][1](gamma), gamma);
[[L1, U1], [L2, U2], [L3, U3]]
end proc;

#Value and Ambiguity:
VT := proc (t::list)
L := t[1];
U := t[2];
v := int((L(alpha)+U(alpha))*alpha, alpha = 0 .. 1);
return v;
end proc;

VI := proc (i::list)
L := i[1];
U := i[2];
 v := int((L(beta)+U(beta))*(1-beta), beta = 0 .. 1);
 return v;
end proc;

VF := proc (f::list)
L := f[1];
U := f[2];
gamma := 'gamma';
v := int((L(gamma)+U(gamma))*(1-gamma), gamma = 0 .. 1);
return v;
end proc;

AT := proc (t::list)
L := t[1];
U := t[2];
a := int((U(alpha)-L(alpha))*alpha, alpha = 0 .. 1);
return a;
end proc;

AI := proc (i::list)
L := i[1];
U := i[2];
a := int((U(beta)-L(beta))*(1-beta), beta = 0 .. 1);
return a;
end proc;

AF := proc (f::list)
L := f[1];
U := f[2];
gamma := 'gamma';
a := int((U(gamma)-L(gamma))*(1-gamma), gamma = 0 .. 1);
return a ;
end proc;

NeutrosophicValue := proc (n::list)
t := n[1];
i := n[2];
f := n[3];
if not IsNeutrosophicCuts(n) then 
y := NeutrosophicAlphaBetaGammaCuts(n);
t := y[1];
i := y[2];
f := y[3];
end if;
return evalf([VT(t), VI(i), VF(f)]);
end proc;

NeutrosophicAmbiguity := proc (n::list)
t := n[1];
i := n[2];
f := n[3];
if not IsNeutrosophicCuts(n) then 
y := NeutrosophicAlphaBetaGammaCuts(n);
t := y[1];
i := y[2];
f := y[3];
end if;
return evalf([AT(t), AI(i), AF(f)]);
end proc;

ValueIndex := proc (n::list, lambda := 1/3, mu := 1/3, nu := 1/3)
return evalf(lambda*NeutrosophicValue(n)[1]+mu*NeutrosophicValue(n)[2]+nu*NeutrosophicValue(n)[3]);
end proc;
AmbiguityIndex := proc (n::list, lambda := 1/3, mu := 1/3, nu := 1/3)
return evalf(lambda*NeutrosophicAmbiguity(n)[1]+mu*NeutrosophicAmbiguity(n)[2]+nu*NeutrosophicAmbiguity(n)[3];
end proc;

CompareNeutrosophicNumbers:=proc(n1,n2::list)
result:=cat(n1," Is the First Number and ",n2," Is the Second Number\n\n");
if ValueIndex(n1)<ValueIndex(n2) then cat(result,"\n1st Number is Greater than 2 nd Number");
elif ValueIndex(n1)>ValueIndex(n2) then cat(result,"\n2nd Number is Greater than 1 st Number");
else 
if AmbiguityIndex(n1)>AmbiguityIndex(n2) then cat(result,"\n2nd Number is Greater than 1 st Number");
elif AmbiguityIndex(n1)<AmbiguityIndex(n2) then cat(result,"\n1st Number is Greater than 2 nd Number");
else cat(result,"\\nTwo Numbers Are Equal");
end if;
end if;
end proc;
end module;

4. Examples

After calling neutrosophic package using with(Neutrosophic) command, lets assume that we have these two single-valued trapezoidal neutrosophic numbers 

Those numbers can be defined by the command:

n1 := NeutrosophicNumber(1, 2, 3, 7, 1, 2, 4, 10, 2, 5, 6, 9); 

n2 := NeutrosophicNumber(2, 4, 6, 10, 2, 5, 6, 8, 3, 4, 5, 9);

and can be plotted by the command:

PlotNeutrosophicNumber(n1); PlotNeutrosophicNumber(n2);

Lets assume that we want to calculate the following:

This can be done easily using the command:

t := NeutrosophicDiv(n1, NeutrosophicSub(n2, NeutrosophicDiv(n2, NeutrosophicMult(NeutrosophicSum(n1, n1), n1))));

and the result can be plotted as follows:

PlotNeutrosophicNumber(t);

Value index and ambiguity index can be calculated by the command:

ValueIndex(t); AmbiguityIndex(t);

Which results:

4.681097490

2.024921163

And we can compare  as follows:

CompareNeutrosophicNumbers(n1, n2);

Which results:

`[[1, 2, 3, 7], [1, 2, 4, 10], [2, 5, 6, 9]] Is the First Number and [[2, 4, 6, 10], [2, 5, 6, 8], [3, 4, 5, 9]] Is the Second Number

2nd Number is Greater than 1 st Number`

5. Conclusions  

In this article, we introduced a Maple package that is a very useful and important tool for decision makers to take their decisions depending on neutrosophic theory by easily doing arithmetic operations which was very hard to do without using this package. This package also allows users to compare two neutrosophic numbers depending on value index and ambiguity index. 

Funding: “This research received no external funding” 

Conflicts of Interest: “The authors declare no conflict of interest.” 

References