Suppose a sum of sines, each depending on a distinct variable x[i]:

>  S := sum(sin(x[i]),i=1..N);

Differentiating wrt to x[i]

> diff(S,x[i]);

should yield cos([x[i]) if i belongs to the interval 1..N, and zero otherwise, but Maple gives

> diff(S,x[i]);
                          N            
                        -----          
                         \             
                          )            
                         /    cos(x[i])
                        -----          
                        i = 1          

which is wrong of course.
 

In a sum I would expect 0 when the minimum index is larger than the maximum index.

Yet Maple 2017.3 does this only for special cases:

> for i from 0 to 4 do
     sum(1,j=i..1);
  end do;
                               2
                               1
                               0
                               -1
                               -2

Dear all,

I am new to Maple and trying to figure out the use of dataframes. The help files say you can use dataframes in plotting but I keep getting errors. I have the following code which uploads a short dataframe with column headers which include x and y. I use

with(plots);
with(Statistics);
mydat := Import("this:///Datafiles/greg.csv"); 

with(mydat);
dataplot(x,y);

I receive the following error message 
Error, (in Plot:-DataPlot) invalid input: lhs received _m4754289856, which is not valid for its 1st argument, expr

Can anyone spot what I'm doing wrong?

Thanks in advance

Jo

How to generate any possible points projective plane for sets of numbers?

bonus is any possible field

Two questions. 

1/ Can we modify the output look of the Quiz question?  (ie change the size of the table that is created - make it smaller?)

2/ How to make an algorithmic question ie. for adding two different numbers using the Quiz command?  What I mean here is to randomly change the numbers each time.

I was trying something like

Quiz("What is ", a+b, proc () local a, b: a := rand(1 .. 20)(): b := rand(1 .. 20)(): end)

But the values don't get passed to a and b so the answer will only be a+b.  Any way to get values passed to the variables?

Does one of these stuctures have any advantage over the other?

I know the loop can be coded in a single statment but i am experimenting

Hi I need to know how to alter my input as to prevent certain things from being displayed in italics, but not others, for example,I type gcd(x,y) as input, I want the variables x and y to be displayed in italics but not "gcd".

I would like to to print the following equation in Maple:

I've run into several problems:

• Using more than one equal sign in an equation.
• Printing the " +...+ " without getting an error
• Making sure that sum(x+1,n=0..N) is formatted like above and not printed as "sum(x+1,n=0..N)"

I've played around with different combinations of Atomic form, the Parse function, and the characters: < ' >, < ` >, < " >, but everytime I solve one of the above problems, I undo the solution to one of the other. This is the closest I've gotten:

Hi Users!

Hope you all are fine here. I want to draw a graphs like this

Here 

y(x)=21.70160211*x^2-35.93499295*x+19.00000000;

and 

y(x-0.8)=21.70160211*(x-.8)^2-35.93499295*x+47.74799436

Please help me how to make this for x when y(x) on x-axis and y(x-0.8) on y-axis. I am waiting your positive response. 

Thanks

Hi guys! First time posting here and I'm very new to Maple too.

I'm using maple right now to calculate statics problems, and for that we've customized some units to better fit what we're working with and want to see in output. In general, it's working great, but sometimes when I try to use the solve function including these units, I get an error mesage I don't really understand..

Here's the unit customization:

So I was hoping someone could help me fix the error(s), or at least understand what the errors mean..

How can I get the vlalue of x, y and z into an expression?

In example here I would like to know the value of 2x+3y+z

many thanks

I'm hoping somebody can help with this problem.

The Poisson Loss Function is defined by the series:

L := sum((n-s)*lambda^n*exp(-lambda)/factorial(n), n = s .. infinity)

Where lambda is the mean value that is prescribed and s is the variable in question.

Now, if the value of L is given, can anyone tell me how to solve for  s?

Poisson Distribution Loss Function Tables are available and give values for s for a given lambda, so I's like to see if Maple can handle this.

Thanks for reading!

How do I get Maple to reduce/simplify the following difference quotient to its lowest terms? Basically I need Maple to rationalize the numerator. Any suggestions on how to do this?

Download rationalize.mw

Consider the `or` procedure.
`or`(x, y)  should be equivalent to  x  or  y.

However:
restart;
x := a=0;
y := b=0;
                           x := a = 0
                           y := b = 0
x or y;
                             false
`or`(x,y);
                         a = 0 or b = 0
%;
                             false
simplify(`or`(x,y));
                         a = 0 or b = 0
eval(`or`(x,y));
                             false

### So,  `or`(x,y)  is not fully evaluated [or simplified?].
### Is this documented somewhere?

# Similarly
`not`(x);
                           not a = 0
%;
                              true
not x;
                              true

Hello! 

I am currently programming the Anderson Acceleration for fixed point iteration in Maple. The algorithm comes from Walker et al. 2011 (ANDERSON ACCELERATION FOR FIXED-POINT ITERATIONS) (if you are interested in this problem please read the short paper). The code that Walker supplies runs fine in Matlab, with qrdelete as a built-in function. However in Maple I have decided to skip operations on QR, and instead opted to create a new QR every time I increase or decrease the amount of residuals df. However, here comes the kicker, somehow Maple decides to turn a vector or matrix into a procedure when I Concatenate, or DeleteColumn. I could really use a working Anderson Acceleration code for my research (my research is not based on AA or root solvers in general, but spectral methods). I will paste the entire code here. This is my attempt at getting Walker's original Matlab code to work in Maple.

I could use some pointers and tips. Can you program this in a more efficient way? I would be happy to learn. *Notice that the code works for a host of different equations, but not all. Feel free to let me know if this question or inquiry is inappropriate and I will of course delete the post.

restart:
Digits:=12:
Runtime:=time():
with(LinearAlgebra):
with(plots):
with(orthopoly):
with(ArrayTools):
    

phix := Vector(2):
X    := Vector(2):
phix[1] := cos(x[2]):
phix[2] := 3*cos(x[1]):
X[1] := 0.0:
X[2] := 0.0:

#Code AndersonAcceleration.
AndersonAcceleration:=proc(N,phi,X0)
global x, xS, here1, here2;
local mMax, itmax, atol, rtol, droptol, beta, AAstart, res_hist, df, DGg, gamma;
local DG, mAA, iter, gval,fval,res_norm, tol, f_old, g_old, y, i, k, Q, R, QRg, dfT, DGT;

(*
%------------------------------------------------------------------------
% Function xS = AndersonAcceleration(N,phi,x0).
%
% Fixed-point iteration with or without Anderson acceleration.
% 'phi' is the fixed point iteration map and 'xS' is the 
% solution, so that xS = phi(xS).
%
% Input arguments:
%    X0 = Initial value solution. Note: In this function this variable 
%        must be a column vector.
%       1. 'mMax' = maximum number of stored residuals (non-negative integer).
%       NOTE: 'mMax' = 0 => no acceleration. default=1000
%       2. 'itmax' = maximum allowable number of iterations. default=1000
%       3. 'atol' = absolute error tolerance. default=1.0e-6
%       4. 'rtol' = relative error tolerance. default=1.0e-3
%       5. 'droptol' = tolerance for dropping stored residual vectors to 
%       improve conditioning: If 'droptol' > 0, drop residuals if the
%       condition number exceeds droptol; if droptol <= 0,
%       do not drop residuals.
%       6. 'beta' = damping factor: If 'beta' > 0 (and beta ~= 1), then 
%       the step is damped by beta; otherwise, the step is not damped.
%       NOTE: 'beta' can be a function handle; form beta(iter), where iter 
%       is the iteration number and 0 < beta(iter) <= 1.
%       7. 'AAstart' = acceleration delay factor: If 'AAstart' > 0, start 
%       acceleration when iter = AAstart.
%
% Output:
% xS = Solution vector.
%
% The notation used is that of H.F. Walker: Anderson Acceleration:
% Algorithms and implementation
%------------------------------------------------------------------------
*)

mMax    := 1000:
itmax   := 1000:
atol    := 1.0e-8:
rtol    := 1.0e-12:
droptol := 1.0e4:
beta    := 1.0:
AAstart := 0:

# Initialize storage arrays and number of stored residuals.
DG := Matrix():
df := Matrix():
DGg := Vector(N);
QRg := Vector(N);
mAA := 0:

for iter from 0 to itmax do

   x:=X0:
   gval := Vector(phi):
   fval := gval - X0:
   res_norm := norm(fval,2):
   print(res_norm);    
   # Set the residual tolerance on the initial iteration.
   if iter = 0 then
      tol := max(atol,rtol*res_norm):
   fi:
    
   # Convergence test, if converged the loop stops.
   if res_norm <= tol then
      print(res_norm);
      break;   # Breaks for-loop
   fi:
    
   # If resnorm is larger than 1e8 at iter > 5, problem stops
   if res_norm >1e8 and iter > 5 then
      print(res_norm);
      break; # Breaks for-loop, diverged
   fi:

   # Fixed point iteration without acceleration, if mMax == 0.
   if mMax = 0 or iter < AAstart then
      # We update E <- g(E) to obtain the next approximate solution.
      for i from 1 to N do
         X0[i] := gval[i]:
      od:
   else
      # With Anderson acceleration.
      # Update the df vector and the DG array.
      if iter > AAstart then
         if mAA < mMax or Size(df,2) = 1 then
            print(whattype(df));
            df := Concatenate(2,df,fval-f_old):
            DG := Concatenate(2,DG,gval-g_old):
         else 
            df := Concatenate(2,df[..,-1],fval-f_old):
            DG := Concatenate(2,DG[..,-1],gval-g_old):   
         fi:
         mAA := mAA + 1:
      fi:   # iter
      print(iter,mAA);
      print(whattype(df));
      # We define the old g and f values for the next iteration
      f_old := fval;
      g_old := gval;
      
      if mAA = 0 then
         # Initialization
         # If mAA == 0, update X <- g(X) to obtain themah next approximate
         # solution. No least-squares problem is solved for iter = 0
         for i from 1 to N do
            X0[i] := gval[i]:
         od:
      else
         if mAA > 1 then
            Q,R := QRDecomposition(df,datatype=float);
            while ConditionNumber(R) > droptol do
                if mAA = 2 then
                   print('here1'):
                   df := convert(DeleteColumn(df,1),Vector);
                   DG := convert(DeleteColumn(DG,1),Vector);
                else
                   df := DeleteColumn(df,1);
                   DG := DeleteColumn(DG,1);
                fi:
                Q,R := QRDecomposition(df,datatype=float);
                mAA := mAA - 1;
                print(Q,R,mAA);
            od:
          
            if Size(df,2) > 1 then
               print(Q,R);
               gamma := LeastSquares([Q,R],fval);
               print(gamma);
            else
               R := norm(df,2);
               Q := MTM[mldivide](R,df);
               gamma := MTM[mldivide](R,Transpose(Q).fval);
               print(gamma);
            fi:
         else
            R := norm(df,2);
            Q := MTM[mldivide](R,df);
            gamma := MTM[mldivide](R,Transpose(Q).fval);
         fi:
 
         if Size(gamma,1) > 1 then
            DGg:=DG.gamma:
         else
            DGg:=DG*gamma;
         fi:

         # Update the approximate solution.
         for i from 1 to N do
            X0[i] := gval[i] - DGg[i];
         od:
         print('Sol',X0);
         
         # Damping for non-zero beta
         if beta > 0 and beta <> 1 then
            if mAA = 1 then
               QRg := Q*R*gamma;
            else
               QRg := df.gamma;
            fi:
            for i from 1 to N do
               X0[i] := X0[i] - (1-beta)*(fval[i] - QRg[i]);
            od:
         fi:# isa(beta ...
         print(iter,mAA);
      fi: # mAA = 0
   fi:# mMax == 0

od:
xS := Vector(N);
for i from 1 to N do xS[i]:=X0[i]: od:
return xS
end:

AndersonAcceleration(2,phix,X):