The description from your instructor uses an expression for f. Your attempt calls Newton with an operator for f. Both methodologies can work, but unfortunately your attempt mixed up the two concepts.

Below I show both with modifications of your code, for f as operator or expression.

By the way, you only have to differentiate once. You don't have to repeat that part of the computation, for each iteration of the loop.

You might find these revisions to your code of some use. I corrected the differentiation and evaluation of the derivative, at a point. I also moved the conditional test into the loop so that it would return (possibly earlier) as soon as any iterate satisfied the criterion.

Download rf.mw

restart;
Newton_proc:=proc(f, a)
  local df,n,x1;
  df:=D(f);
  x1:=a;
  if abs(f(x1))<=10^(-8) then
    return x1;
  end if;
  for n to 9 do
    x1:=x1-f(x1)/df(x1);
    if abs(f(x1))<=10^(-8) then
      return x1;
    end if;
  end do;
  return FAIL;
end proc:

Newton_proc( x->x^3-3*x^2+2*exp(x)+5, -1.2 );
         -1.162515305

Newton_proc( x->arctan(x), 1.5 );
              FAIL

restart;
Newton_expr:=proc(f, a)
  local df,n,x,x1;
  x := indets(f,And(name,Not(constant),
                    satisfies(u->depends(f,u))));
  if nops(x)<>1 then
    error "expecting an expression depending on one name";
  else
    x := x[1];
  end if;
  df:=diff(f,x);
  x1:=a;
  if abs(eval(f,x=x1))<=10^(-8) then
    return x1;
  end if;
  for n to 9 do
    x1:=x1-eval(f,x=x1)/eval(df,x=x1);
    if abs(eval(f,x=x1))<=10^(-8) then
      return x1;
    end if;
  end do;
  return FAIL;
end proc:

Newton_expr( x^3-3*x^2+2*exp(x)+5, -1.2 );
          -1.162515305

Newton_expr( arctan(x), 1.5 );
              FAIL

You could simplify the system of equations by the constraint equations, prior to calling solve. (I did this a few hours ago. You can compare with vv's suggestion.)

Download Example_ac.mw

What properties do you know about the variables?

Download Q20201001_ac.mw

If I understand your goal properly, then one way is to first select all the terms which satisfy
the second condition, and then to select from that those terms which have the least degree.

Download poly_deg_query.mw

A 3-D simplicial facet is a facet of a 3-D simplex, ie. a triangle.

Download hull3D.mw

I suppose that you have already searched the FAQs.

You could contact Maplesoft Technical Support.

Be sure to let them know your Maple version, Operating System and version, and whether you are using any Maple "language packs".

Using concatenated names (which are always global) within procedures is poor programming practice, in my opinion.

Having said that,

Download Concatenate_Question_ac.mw

You could also use  cat(':-A',1)  for additional safety.

You can pick off those introduced (free) parameters, evaluate expressions (C, Q, other...) at arbitrary values for them, and so on.

Forcing the stem of the parameter name with the free option makes it easier to pick them off programmtically in the more general case.

Another choice is to use LeastSquares instead of LinearSolve, which will produce a single instance of the solution rather than a parametrized solution.

(I changed the first two entries of B, to make the LeastSquares result more interesting than the zero-Vector.)

Download MultipleTCoefficients_ac.mw

Download doubleint1.mw

If I understand your goal correctly, the coordinates of the cells are present in the plot structure computed by the VoronoiDiagram command.

They are Matrices, but you could convert them to listlist.

Let us know if you have difficulty converting or manipulating them into some other form. Please be specific in details, though. If you want them merged, without repeats, into one big flat list of points then that could be done -- though if there are very many original data points it computed be computed more efficiently in a more direct manner (via Delaunay triangulation, say), without going through production of the full diagram/plot.

Here is an example, separating then according to the color.

Download Voronoi_cells.mw

The result coming out of symbolic int (from the meijerg method) is incorrect.

You can very quickly produce a plot as follows, however, using numeric integration. Note the use of inert (captalized) Int below, instead of active int.

Here I get good speed by forcing a numeric integration method which avoids (here unnecessary) expensive discontinuity checking.

plot(Int(exp(-(x^2-a)^2),x=0..infinity,method=_d01amc),
     a=-2..5);

Other quick approaches here include specifying a decent method other than _d01amc (eg. _Dexp) or utilizing operator form for the integrand within the Int call (slightly tricky since the value of parameter a has to be shoehorned in). These are not quite as quick as the approach given above.

plot(Int(exp(-(x^2-a)^2),x=0..infinity,method=_Dexp),
     a=-2..5);

plot(a->Int(unapply(exp(-(x^2-a)^2),x),0..infinity),
     -2..5);

Using Int (or int with its numeric option) alone for this example is considerably slower slower than the approaches mentioned above. These next approaches will also produce the better plot, but they are not nearly as fast (because of hybrid symbolic-numeric checking), taking about 60sec versus less than 1sec for the first approach above. The slowness is not due to the accuracy tolerance.

plot(Int(exp(-(x^2-a)^2),x=0..infinity),a=-2..5);

plot(a->int(exp(-(x^2-a)^2),x=0..infinity,numeric),-2..5);

I will submit a bug report against the symbolic int command, for the incorrect result coming out of the meijerg method.

If you read the Help page for Topic proc you can see a description of the fact that local variables only get 1-level evaluation.

You code does a rather unusual and roundabout trick of creating expressions with references to y, and then temporarily assigning specific values to y (eg. y=0, y=b), and then unassigning y. It does this while constructing the expressions that get assigned to EQ1,EQ2,EQ3, and EQ4.

When you do all that at the top-level then the expressions assigned to EQ1,etc get fully evaluated, and the references to y are replaced by the values temporarily assigned to y, and no references to y remain.

But when you do that within a procedure (where y, GenFunc, EQHelp, and EQHelp2 are local variables -- whether declared explicitly or not) the references to local y only get 1-level evaluation, and are not resolved to the temporary assigned values.

There are several ways around this:

A) You could wrap in a simple call to eval, each of the four constructions. For example, instead of,
          EQ1 := GenFunc = 0;
you could have,
          EQ1 := eval(GenFunc = 0);
while retaining you temp assignments to y, and unassignments of y (so that the diff calls were still valid). This is workable, but retains what I consider to be a very awkward way of doing something that should be simple. The fact that you have to repeatedly unassign y is a hint that is suboptimal. This is not the best direction in which to move. Test_GetDet_MaplePrimes_assign_eval_unassign.mw

B) You could declare EQHelp, EQHelp2, and GenFunc as a global at the top of the wrapping GetDet procedure, and keep all the other mechanisms as they are. That works, but retains all the awkwardness. It's actually more awkward and convoluted. (For other examples you may get lost trying to figure out what to declare global. Also, unnecessary global declarations are evil and wicked.) This is the wrong direction in which to move. Test_GetDet_MaplePrimes_globaldecl.mw

C) You could get rid of all the need for repeated assigning and unassigning to y, by instead using the so-called 2-argument calling sequence of the eval command to evaluate GenFunc, EQHelp, and EQHelp2 at the specific values of y. This is much more usual and convenient way to utilize a value for a variable without having to unassign it for subsequence symbolic use (the ensuing diff calls). This is the right way to accomplish this part of the task (IMO), regardless of whether inside a wrapping procedure or all done at the top-level. Test_GetDet_MaplePrimes_ac.mw

You keep submitting duplicates of earlier question threads. You spam this site with them. It is inconsiderate and unhelpful. I flag them as duplicates, and then delete them. I have given you messages about this -- as private messages and comments on earlier Questions.

Put your followup queries onto one of your related earlier Questions, instead.

If you have other kinds of example then you should show them.

Download indets_exp.mw

Some instructor has a sense of humour.

(I made no effort for efficiency.)

Guessing at how num2text might work was not difficult.

Download hwQuestion.mw