You just need to set the environment variable ?UseHardwareFloats :

UseHardwareFloats:= false;

Let me know how that goes.

(You probably know this, but I'll say it anyway: Maple's floating-point system is base 10, not base 2. So don't expect some of the standard examples of floating-point errors to work exactly the same way as is shown in the textbooks.)

You need to put forget(x) before the x:= proc....

Since Maple allows a newline character anywhere that it allows whitespace, continuation characters are very rarely needed. Your example would work just as well without the backslash. Even long strings can be split "simply "
"like "
"this."

There is no logical concept of a "line" of code in Maple. Statements can, and often do, go on for tens of lines.

That being said, I have no information about the situation in Maple IDE.

Instead of type(e, negative) you need to say is(e < 0). The type of an expression is an inherent property of the expression, and it is not affected by assumptions.

You should not use and in the assumptions; just separating them with the commas is logically equivalent to and.

Putting it together, your statement should be

is(e < 0) assuming  
     d1 > 0, d2 > 0, d3 > 0, Kw > 0, Ks > 0,
     0 < pfw1, pfw1 < 1, 0 < pfw2, pfw2 < 1, 0 < pfw3, pfw3 < 1,
     0 < pfs1, pfs1 < 1, 0 < pfs2, pfs2 < 1, 0 < pfs3, pfs3 < 1,
     d1-pfw1*Kw-pfs1*Ks > 1, d2-pfw2*Kw-pfs2*Ks > 1, d3-pfw3*Kw-pfs3*Ks > 1,
     pfw1 <> pfw2, pfw2 <> pfw3, pfs1 <> pfs2, pfs2 <> pfs3
;

Maple's response is false.

Addressing your question 2: There is no algorithm for deriving the conditions under which a complicated, non-polynomial, multivariate expression is negative (or positive, or zero).

Let's say that your expression with the h for the difference quotient is called dq. Then you need to say

limit(dq, h= 0);

Here's your problem:

f:= x-> x^3+3*cos(x):
dq:= (f(x+h)-f(x))/h:
limit(dq, h=0);

Change plot3d to plots:-implicitplot3d. Then adjust the ranges of x, y, and z to get a better plot.

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.