Here's how to do it with the order. That is, how to run Maximize and save each call to the objective function and the order that the calls were made.

Please let me know if you are able to apply this to your problem.

Download Max_with_saved_dat.mw

conjugate(1/sqrt(I*t*lambda+m))*sqrt(lambda^2*(t^2)+m^2)*(1/sqrt(I*t*lambda+m)):
simplify(evalc(%));
                               1

It would not be possible for Maple in general to implement what you want. Maple deals with polynomial arithmetic over finite fields. x^2+x+1 is considered an irreducible polynomial over Z[2]; it is not equivalent to 1. So Z[2]/(x^2+x+1) is the finite field with 4 elements.

But, you can easily redefine mod to suit your purposes:

restart:
Modp:= eval(modp):
unprotect(modp):
modp:= (e,m)-> Modp(`if`(m=2, evalindets(e, `^`, x-> op(1,x)), e), m):
protect(modp):

x^2 mod 2;
                                            x

a*b*c+a^2*c*d+d+c^2*d^2*a^2*b^2+d^2*a*b^2*c+d^2*a*b^2+a*c+c*d+d*b+d*a^2*b*c+c+c^2+d^2*a^2*c+d^2*a^2*b^2*c+d^2*b^2+d^2*a+
d^2+b*c^2+c^2*d^2+b*c^2*d+a^2*c^2*b*d+c^2*d^2*a^2+c*d*a*b+a*b^2*c*d+b^2*c*d+b^2*c^2*d+d^2*a*c+a^2*b^2*c^2*d+b*c+d*a*b+d*a+
a^2*c^2+a^2*c^2*b+c^2*d^2*b^2 mod 2;
                                             0

Yes, function application distributes over most other operators; and constants, when applied as functions, become constant functions. Example:

((D-2)^3)(sin)(x);

There is a missing character between your k and 1. I will assume it is a plus sign. You can enter the expression pretty much as you currently have it into Maple:

Limit((Sum((n-k)/(k+1), k= 0..n-1) -ln(n!))/n, n= infinity);

value(%);

                                      γ

The answer is hard to read when I cut-and-paste it above, but it is the Euler-Mascheroni constant, gamma.

No, it can't be done.

Please post the example. It might help if you give fsolve a hint by making an initial guess based on an implicitplot.

See the section "Fundamental Recurrence Relation" of the Wikipedia article "Generalized Continued Fraction".

Download gen_cont_frac.mw

It's as simple as

(A_old,A_new):= (A_new,A_old):

Ordinary assignment (via :=) only copies the addresses of tables and arrays, which is what you want. Multiple ordinary assignment is done in such a way that an intermediate variable is not necessary.

1. You probably used an e somewhere earlier in your computation where you had meant to use exp. If you print the expression with lprint, it will show you if the e is actually exp(1).

2. Yes, the argument of a positive real number is 0.

It is surprising that there is no single command to do this. So I wrote a procedure to do it.

To use this, you'll need to download a combinatorics package called Iterator from the Maple Applications Center. The package has a command SetPartitions which lets you control the size of the blocks in the partition, but you can't directly control the number of blocks. So I iterate over the integer partitions of n to get all possible combinations of block sizes with k blocks. Then these need some modification to be put into the form expected by SetPartitions.

PartitionIntoKBlocks:= proc(n::{set,nonnegint}, k::nonnegint)
option `Written by Carl Love 2013-Sep-27.`;
uses J=Iterator, C= combinat, S= Statistics;
local s, P, N:= `if`(n::set, n, {$1..n});
     {seq(
          seq({s[]}, s= J:-SetPartitions(N, map(`[]`@op, S:-Tally(P)), compile= false)),
          P= select(x-> nops(x)=k, C:-partition(nops(N)))
     )}
end proc:

PartitionIntoKBlocks(4,2);
    {{{1}, {2, 3, 4}}, {{2}, {1, 3, 4}}, {{3}, {1, 2, 4}},
      {{4}, {1, 2, 3}}, {{1, 2}, {3, 4}}, {{1, 3}, {2, 4}},
      {{1, 4}, {2, 3}}}

Joe Riel, if you're reading: I think Iterator:-SetPartitions should have an option for the number of blocks in the partition.

This was trickier than I expected, probably because of a bug in Maple.

a,b,c:= 'RootOf(x^3-x^2-x-1, x, index= k)' $ k= 1..3:
evala(
     evala((a^2014-b^2014)/(a-b)) +
     evala((b^2014-c^2014)/(b-c)) +
     evala((c^2014-a^2014)/(c-a))
);

8334826359539004144901989461804527198477505526542440583547585702\
  52333926756888184793278322997734194204312479082099178141286346\
  19093619632692976466847552803713809622682218736343227666160495\
  08221814701281712551536720818416541447585602970496630535429027\
  14035268777406803186312918798664076365740099763393011180604524\
  46886004153088055743393327297340352231807305287646640702341995\
  05000473477741234080182885893584028536441114628416893583917671\
  56862792958972093429609456884388481631837778020024880944176069\
  54812869711446457823816195550797524

The answer is just a large integer. It is a[2014] for the Fibonacci-like recurrence a[n] = a[n-1]+a[n-2]+a[n-3], a[0]=0, a[1]=3, a[2]=2.

The bug ensues if you try to do it with a single evala command. It seems to get stuck in an infinite loop.

Download linear_approx.mw

Download sensitive_equatio.mw

First, it helps tremendously if you indent your code, like this:

restart:
P := array([[1, 4], [2, 3], [3, 2], [4, 1], [6, 5], [6, 1], [6, 2], [5, 3]]);

j := 1; k := j+2; Fold := 0; Fnew := 1; counter := 0;

for i to 6 do 
     j := i; k := j+2;
     while Fnew > Fold do 
          Fold := Fnew; 
          L[j, k] := evalf((P[k, 1]-P[j, 1])^2+(P[k, 2]-P[j, 2])^2)^(1/2); 
          m[j, k] := (P[k, 1]-P[j, 1])/(P[k, 2]-P[j, 2]); 
          a := m[j, k];
          b := -1; 
          c := P[j, 2]-m[j, k]*P[j, 1]; 
          for i from j+1 to k-1 do 
               e[i] := evalf(abs(a*P[i, 1]+b*P[i, 2]+c)/sqrt(a^2+b^2));
               E[j, k] := sum(e[m], m = j+1 .. k-1)
          end do; 
          Fnew := L[j, k]-E[j, k];
          counter := counter +1; 
          k := k+1 
     end do;
     right[j] := k-2
 end do;

And when I look at it like that, I immediately see the problem: You used the same index variable, i, for both the inner and outer for loops. So I simply changed the loop index to ii for the inner loop, and I changed its three invocations within the loop to ii also:

          for ii from j+1 to k-1 do 
               e[ii] := evalf(abs(a*P[ii, 1]+b*P[ii, 2]+c)/sqrt(a^2+b^2));
               E[j, k] := sum(e[m], m = j+1 .. k-1)
          end do;

And then I got 6 values in right.