@delvin 

Hi,

That's would be to much work for me, not to mention the fact that writing this code requires an even more description of the DNSE method.
Hope you will find someone else to help you.

@delvin 

when you write "Can someone guide me on how to write the code for this program?", what do you mean exactly?

• Do you want to write a code which "proves" the equations (14) given equation (9) and all the stuff in between?
  if it is so, here is a code  From_9_to_14.mw
   
• Or do you want to solve equations (14) and prove a particular solution as the form you give?
   
• Or maybe something else?

@delvin 

I'm going to look more closely to the paper.

@MANUTTM 

My mistake, the determinaant is 

-(1/4)*Ch^2/D^2

and I read it 

-(1/4)*C*h^2/D^2

when I wrote my re^ly.

So the determinant is always negative and the hessian matrix is never positive definite.

To check if it negative definite the first minor of this matrix must be negative.
Look at the end of this file q2b_mmcdara.mw

So, the hessian matrix never being positive  definite, there is no point in R³ at which TPpm reaches a minimum.

relative to the docs reference:

• What happened to index n in equation (4) ?
  As you write it the formula means nothing.
   
• In equation (9), is "i" the imaginary unit?
   
• Next line, what does DNSE mean?
   
• How can you transfor the single equation (9) into a system of 2 equations (12)?
  Is it assumed that u(t) = UA(t)+I*V(t)  and that phi(t) = P(t)+I*Q(t) with both A, B, P, Q functions with values in IR ?
  In which case (12.1) could be Re(eq(9)) and (12.2) Im(eq(9)) ?

Can you provide a more solid reference for what you want to achieve for, at least for me, it is incomprehensible.
TIA

@MANUTTM 

You never calculate the Hessian of TPpm wrt Q and Qr.
You define a, b, c this way

a := diff(TPpm(Q, Qr), Q$2):
b := diff(TPpmg(Qr), Qr$2):
c := diff(TPpm(Q, Qr), Q, Qr):

On the other way TPpmg(Qr) is given by

TPpmg := Dr -> subs([g1], TPpmm(Q, Qr))

and then IS NOT identical to TPpm(Q, Qr).

Then the matrix 

Matrix(2, 2, {(1, 1) = a, (1, 2) = c, (2, 1) = c, (2, 2) = b})

is not the hessian matrix of TPpm(Q, Qr).

The Hessian of TPpm(Q, Qr) is 
 

Then the conditions for H to be definite positive are:

• det > 0 ==> C < 0
• H[1, 1] > 0 thus

  solve({H[1, 1] > 0) assuming C < 0:
  print~({%}):
                       {0 < Ch, 0 < P, D < 0}
                       {0 < Ch, 0 < P, P < D}
                       {0 < D, Ch < 0, P < 0}
                       {Ch < 0, D < P, P < 0}
                   {0 < Ch, D < 0, P < 0, P < D}
                   {0 < D, 0 < P, Ch < 0, D < P}
  

   

Complete file here q2_mmcdara.mw

@NanaP 

Thanks

@NanaP 

A simple way is to insert a 

DEBUG():

command BEFORE the portion you want to debug.
This command MUST be located AFTER the last local and global declarations.

This means that instructions like

local eqs := {F(Q[1])=P[1], F(Q[2])=P[2]}:

cannot be debugged.

You must change the code this way

Download TriangularDistribution_V2d.mw

When you run the command

T := TriangularTypeII([3, 5], 4):

the debugger is not invoked.
But if you run this one

T := TriangularTypeII([3, 5], 4, debugmode=true):

the debugger opens a pop window in which you can execute step by setp the procedure and see what happens.

Type help(DEBUG) for more information.

Another way I'm less familiar with is to use the Maple debugger directly from your worksheet.
Type help(debugger) for more information.

As I use to use interactive debuggers in other languages, I prefer using DEBUG() in the way I present in the attached file (this mimic a compilation directive).
But I'm not competent enough to say which of the two methods is more efficient.

@NanaP 

Let me know if you have any problems.

Maple offers the possibility to define optional arguments for a procedure.
Optional arguments are gathered in a set of the form

{OptArg1::type:=DefaultValue1, ...OptArg?::type:=DefaultValueN}

If the procedure is regularly called with an argument which has a given value, you can declare this argument as optional and define this value as its default value.
In the attached file I assumed that  you generally call TriangularTypeII with Q=[Fitst Quantile, Third Quantile]:
TriangularDistribution_V2c.mw

@MANUTTM 
Simplifyng g1 seems a dead end to me.
Getting rid of the "1." you mention is easy.
q1_2_mmcdara.mw

Can you precise your last question?

Minor1 := simplify(H[1, 1]);
Minor2 := d;
              /    2      3      2            2     3\
           Ch \P Qr  T - Q  - 3 Q  Qr - 3 Q Qr  - Qr /
         - -------------------------------------------
                                     3                
                           P (Q + Qr)                 
                              2    2  
                            Ch  T Q   
                         - -----------
                                     3
                           P (Q + Qr) 
# H is positive definite if Minor1 and Minor2 are both > 0
#
# If H is positive definite at a given point (Ch, P, Q, Qr, T) then 
# this point is a minimum of TPpm.

@NanaP 

 

How Maple realize that the pairs of Q and P are quantiles and their probabilities (the 2 pairs) in this equation:  local eqs := {F(Q[1])=P[1], F(Q[2])=P[2]}

This is the definition I adopt when I build the distribution: the first argument Q is a list of 2 quantiles and the second P is the list of their associated probabilities.
I hesitated between this definition and this one:

• the first argument is a couple (quantile, probability), let's say A,
• the second argument is another couple (quantile, probability), let's say B.

(or A and B are 2 couples (probability, quantile), maybe)

Whith this choice

eqs := {F(Q[1])=P[1], F(Q[2])=P[2]}

would have been written

TriangularTypeII := proc(A, B, c)
...
eqs := {F(A[1])=A[2], F(B[1])=B[2]}
...

By the way, a safer construction of the calling arguments is

TriangularTypeII := proc(A::list(numeric), B::list(numeric), c::numeric)

This construction returns an error if you call TriangularTypeII with formal arguments (see my second reply), for instance

TriangularTypeII([q1, p1)], [q2, p2], c)

produces an error as soon as at least one of these five quantities is not a number.


Here is an example where I used the option description as an operand of the procedure (see help(procedure)) and the function Describe to get some information about this procedure.
 

Download TriangularDistribution_V2b.mw

At the very end, if you have several reparameterized distributions to build, or new ones to construct, it worth wtitting help pages for each of them (see help(Templates)) and gather all these distribution in a specific package.

@NanaP 

Thaks for your kind reply.

As you probably understood the trick (as in the definition of the SubjectiveBeta distribution --at least the revised version of my answer--) is to transform the 5 parameters (Q, P, c) into 3 parameters (a, b, c), and then Use the Triangular(a, b, c) distribution.

Based on the use of the function Statistics:-Specialize, there is a shorter version of my previous file.
TriangularDistribution_V2.mw

It gives exactly the same results than the first version, but I don't like it because the TriangularTypeII distribution is not really defined: what I do here is, starting from an abstract Triangular(a, b, c) distribution, to build a triangular random variable whose parameters are no longer  (a, b, c) but (Q, P, c).
Statistics:-Specialize plays a key role here but, I repeat, the TriangularTypeII distribution doesn(t really exist.

About your "4 solution issue".
There is an explanation:

Download TooManySolutions.mw

@Aung 

Download DoYouWantThis.mw

@Anthrazit 

You should have attached this file when you asked your question, this would have saved me from taking off in the wrong direction and wasting my time.

@Anthrazit 

That doesn't change anything: your code still runs without errors with Maple 2015:

Download 2015_a.mw

Maybe you should add this line after the last local declaration

print(detail(segm));

to see what segm really is.
You should get this`

[name of the object          segm
form of the object           segment2d
the two ends of the segment  [[0,0],[1,1]]