acer

32313 Reputation

29 Badges

19 years, 315 days
Ontario, Canada

Social Networks and Content at Maplesoft.com

MaplePrimes Activity


These are replies submitted by acer

@lcz My use of _rest was within the procedure ex2. As Carl mentioned, it allows extra arguments to be passed along.

In this situation it would allow someone to optionally adjust the `frontend` use, in a call-by-call way.

The _rest doesn't mean anything outside any procedure. At the top-level it's just a name. So it's incorrect to use it as you did.

@Christopher2222 Here are some ideas. You don't have to use %* instead of wrapping the first multiplicand in a call to ``(), though I prefer it.

But I really do think that it's better to frontend the expand call, as that last example in this example demonstrates.

extr.mw

@Matt C Anderson How does that help in factoring the example in the Question?

Vote up.

The OP might be interested in simpliying that result. There are various ways to do that, eg.

P := x^4 - x^2 + x - 1:

raw := convert(PolynomialTools:-Split(P, x), radical);

new := map(collect,raw,x,simplify@rationalize);

@mmcdara I believe that the OP is asking about whether the Topic string of the currently opened Help page can be obtained while viewing it.

@gkokovidis That does actually have a boundary. (The boundary is a CURVES plotting substructure, and the filled region is a POLYGONS substructure.) You notice the boundary less here because it is red while that from the ellipse command is black by default.

But in your example the filled region is noticeably not rendered as red, and thus not a color match to the boundary. It is rendered noticeably lighter than red. That is because the plotting command sticks in 0.4 for the transparency of the filled region.

You can use a parametric form and get the whole thing (fill and boundary) rendered with the same shading by suppressing that transparency of the filled region. Eg,

r:=theta->2/sqrt((2*sin(theta))^2+(1*cos(theta))^2):
P:=plot([r(theta)*cos(theta),r(theta)*sin(theta),theta=0..2*Pi],
        filled=true,color=red,transparency=0,
        scaling=constrained,axes=none,size=[1000,500]);

Your formula given for -rA (along with the integral in your image) don't agree with the integand in your call to int. Is the integrand 1/(-rA) or is it -rA?

The shown formulas imply X*(1-X) is in the numerator, but your attempt at integration has it in the denominator.

@tomleslie Unfortunately the OP has omitted the context in which his piece of code made better sense.

I suspect that the context was such that the upright roman characters were desirable, and in which the goal was to prevent reformatting (in another notation) of the floating-point value by the interface. Perhaps it was connected to text appearing in a plot.

@mmcdara In your followup's second example the term sin(X(t)) appears in the result, whereas in your followup's first example k*X(t) does not appear in the result. Hence you see the psi in the second, but not phi in the first.

If you don't want psi to appear then you could remove the alias. (I'm not sure I understand when you do or do not want the effect of the alias in output, given both your original question and your followup.)

restart;

alias(X = X(t)):
alias(Phi=Phi(X(t))):
alias(psi=k*X(t)):

value(eval((Diff(Phi, t, t), Phi=psi)));

k*(diff(diff(X, t), t))

restart;

alias(X = X(t)):
alias(Phi=Phi(X(t))):
alias(psi=sin(X(t))):

expr := value(eval(Diff(Phi, t, t), Phi=psi));

(diff(diff(X, t), t))*cos(X)-(diff(X, t))^2*psi

alias(psi=psi):

expr;

(diff(diff(X, t), t))*cos(X)-(diff(X, t))^2*sin(X)

Download alias_ex2.mw

You wrote, "I want each element in the array to be an empty list, so I can later add to it."

That is inefficient, and not sensible, since a list is not really a mutable data structure.

@janhardo 

restart;

 

SumList:= proc(L::list)
  local S, i;
  S := 0;
  for i from 1 to nops(L) do
    S:= S + L[i];
  end do;
  return S;
end proc:

 

SumList( [13, 4, 26, -3] );

40

SumList:= proc(L::list)
local S, i;
  S := 0;
  for i from 1 to nops(L) do
    print(sprintf("adding element L[%a]=%a, to %a", i, L[i], S));
    S:= S + L[i];
    print(sprintf("sum so far is %a", S));
  end do;
  return S;
end proc:

 

SumList( [13, 4, 26, -3] );

"adding element L[1]=13, to 0"

"sum so far is 13"

"adding element L[2]=4, to 13"

"sum so far is 17"

"adding element L[3]=26, to 17"

"sum so far is 43"

"adding element L[4]=-3, to 43"

"sum so far is 40"

40

Download SumList.mw

@vv Sure, and the given Wind procedure can only handle vertical and horizontal lines (which the starting values for the red vertices happen to incur). It might be extended to check for the blue point being on (or close enough) to any of the line segments no matter the slope.

If we allow only  the blue test point to be mouse-dragged, then it can be done with discretized values.  explore_wind_ac2.mw

@vv That is fun.

Attached is a variant in which the red and blue points can be dragged around with the mouse. (I used Maple 2021.1)

explore_wind_ac.mw

@Jean-Baptiste R I'm glad that you're able to make progress.

But note that the alteration sought here is not really a "factorization".

If I do a google search for "efficient polynomial evaluation" then the second hit is to Horner's Method.

Here's another approach, which sometimes turns up something useful,

expr := a*x+6*x^2-10;

a*x+6*x^2-10

codegen['optimize'](unapply(expr,x),'tryhard')(x);

-10+(a+6*x)*x

Download code_opt_fun.mw

Please don't start an entirely new thread on the same question.

First 118 119 120 121 122 123 124 Last Page 120 of 591