mmcdara

At least two ways...

Answered: mmcdara 7891

November 02 2023

2 1

>

>	kernelopts(version):

>

minimum := eval(T, [y=0.5, beta=-3]):

c := contourplot(T, beta = -3 .. 3, y = -.5 .. .5, filledregions=true, coloring=["Blue", "Yellow"]):
p := plot3d(T, beta = -3 .. 3, y = -.5 .. .5, style = surfacecontour, colorscheme=["Blue", "Yellow"]):
phi := plottools:-transform((x, y) -> [x, y, minimum*1.2]):
display(p, phi(c), orientation=[130, 73, -34])

>

maximum := eval(T, [y=-0.5, beta=3]):
cont := [seq(minimum..maximum, (maximum-minimum)/10)]:

c := contourplot(T, beta = -3 .. 3, y = -.5 .. .5, contours=cont, color=gray):
p := plot3d(T, beta = -3 .. 3, y = -.5 .. .5, style = surfacecontour, contours=cont, colorscheme=["Blue", "Green", "Yellow", "Red"]):
phi := plottools:-transform((x, y) -> [x, y, minimum*1.2]):
display(p, phi(p), phi(c), orientation=[130, 73, -34])

>	# this corresponds the attached picture you provide in your question p := plot3d(T, beta = -3 .. 3, y = -.5 .. .5, style = patch, colorscheme=["Blue", "Green", "Yellow", "Red"]): phi := plottools:-transform((x, y) -> [x, y, minimum*1.2]): display(p, phi(p), orientation=[130, 73, -34])

>

Download At_least_two_ways.mw

One Way...

Answered: mmcdara 7891

November 02 2023

0 11

Here is a solution:

One_way.mw (UPDATED)

I didn't read your 3 self-replies but......

Answered: mmcdara 7891

November 01 2023

1 2

... here is something that could help you.
Formal and numerical resolutions are proposed, the latter approach is done in two different ways.
sol_1.mw

ImageTools ?...

Answered: mmcdara 7891

November 01 2023

1 10

Did you try ImageTools?

Download Images.mw

The four images:

Statistics:-Trim seems to do what you wa...

Answered: mmcdara 7891

October 28 2023

1 4

Statistics:-Trim seems to do what you want:

>

restart

>	with(Statistics):

>	N := 10^5: X := Sample(Uniform(0, 1), N): t0 := time(): k := 1000: # 1000 elements to select # the 1000 smaller CodeTools:-Usage( Trim(X, 0, 100*k/N) ):

memory used=2.87MiB, alloc change=0 bytes, cpu time=10.00ms, real time=126.00ms, gc time=0ns

>	randomize(): X := Sample(Uniform(0, 1), N): # the sorted 1000 smaller CodeTools:-Usage( sort(Trim(X, 0, 100*k/N)) ):

memory used=1.55MiB, alloc change=1.53MiB, cpu time=2.00ms, real time=2.00ms, gc time=0ns

>	# Using sort: randomize(): X := Sample(Uniform(0, 1), N): CodeTools:-Usage( sort(X)[1..k] ):

memory used=0.85MiB, alloc change=7.33MiB, cpu time=16.00ms, real time=5.00ms, gc time=0ns

>	alias(ST = StringTools):

>	N := 10^5: K := 10^3: text := (ST:-Explode@ST:-Random)(N, 'alnum'):numelems(text); CodeTools:-Usage( ST:-Char~(Trim(ST:-Ord~(text), 0, 100*K/N)) ):

memory used=9.22MiB, alloc change=0 bytes, cpu time=64.00ms, real time=64.00ms, gc time=0ns

>

Download PartialSorting.mw

varphi_c_c and var_phi_f not define......

Answered: mmcdara 7891

October 28 2023

1 0

@Sky-Bj

varphi_c_c and var_phi_f not defined (see @Axel Vogt )
See here

>

restart

>	V := m^4*(varphi/M)^p:

>	V1 := diff(V, varphi):

>	V2 := diff(V1, varphi):

>	f := Zeta * (varphi^2):

>	f1 := diff(f, varphi):

>	f2 := diff(f1, varphi):

>	R:= simplify((V/3-f1V1/3V)/((1-kappa^2f)/12kappa^2+f1/V)):

>	ToInt := 3V1kappa^2((2VV1)/3 - f1^2V1R/(3V) - f1V1^2/(3V))/(V(-fkappa^2 + 1)(-Rf1 - 2*V1)): FromTo := varphi=varphi__c..varphi__f: # Use your own range

>	data := [p=2, Zeta=1/6,M = 1, m = 1, kappa=1, varphi__c=0, varphi__f=1]: # Use your own range meth := method=_DEFAULT: # Change it evalf(eval(Int(ToInt, FromTo, meth), data));

(1)

>	limit(eval(ToInt, data), varphi=0, right); plot(eval(ToInt, data), eval(FromTo, data))

>	data := [p=2, Zeta=1/6,M = 1, m = 1, kappa=1, varphi__c=1e-2, varphi__f=1]: evalf(eval(Int(ToInt, FromTo, meth), data));

(2)

Download How_to_integrate.mw

What a shame you changed the left bc !...

Answered: mmcdara 7891

October 24 2023

0 1

@Vortex

... for one can find the exact solution of your initial problem.
This is not that immediate, but it is possible, at least after a few trials and failures and with the help of an intermediate plot:
dsolve_exact.mw

solution := tanh((1/4)*sqrt(2)*x+(15/4)*sqrt(2))

The exact solution of your "new" probem (z(0)=0, z(15)=1) is here
dsolve_exact_new_problem.mw

solution := tanh((1/4)*sqrt(2)*x)

NewtonsMethod's help page:The Newton...

Answered: mmcdara 7891

October 23 2023

1 2

NewtonsMethod's help page:
The NewtonsMethod(f(x), x=a) command returns the result of applying 5 iterations of Newton's method for approximating a root.
So do not expect this command gives a converged result, it has to be used mainly to illutrate graphically how the Newton's method works (more: the Newton's method not always converges).

Bisection's method:
As f:=sin(x)+1 is never negative this method cannot be applied (it requires that the target function has opposite signs at the bounds of the initial interval.

A correct example

>

f := sin(x)+.95; 1; plot(f, x = -3 .. 2)

>

(1)

>

(2)

>

omega := [-1.5, 0]:

(3)

>

Download help_roots_corrected.mw

Use ListTools:-Search...

Answered: mmcdara 7891

October 23 2023

2 0

ListTools:-Search(96, R);

Without even using maplemint one can see...

Answered: mmcdara 7891

October 22 2023

2 17

Without even using maplemint one can see a lot of errors in your procedures.

In the attached (yellow highlighted red text) file some of these errors are fixed but it remains a lot of ambiguities.
Having said this, I have the feeling that what you are trying to achieve could be done more simply:

Procedure CC seems to be the discrtization of a first order ode with a forward Euler scheme?
Procedure normalisatie could be written in a single line.
Procedure integraal is a numeric integral with trapezoid rule (am I right?)
Finally optimalisatie seems to be a procedure to find the 0 of some function with a dichotomy strategy (am I right?)

Perhaps you should simply explain what your problem is so that you can receive more appropriate assistance?

Anyway here is my analysis of youy file

>

restart

>	C__0 := 100010^(-9): Q := .8((1/6)10^(-7)): R := 289.110^(-6): V__r := 810^(-6): m__b := 1.510^(-3): rho := 290.: Gamma__i := 3.0110^(-6)((1/6)*10^(-8)):

>	T__ex := [0, 30, 60, 120, 240, 360]*~60: Cl__ex := [1, .56, .45, .32, .18, .11]:

>

CC := proc (C__0, Q, V__r, m__b, rho, R, Gamma__i)
  local t, dC, C__i, i;
  t := Vector(360,i -> 60*i);
  C__i := Vector(360, 0);
  C__i[1] := C__0;
  for i to numelems(t)-1 do
    dC := -Q*(1-exp(-3*m__b*sqrt(Gamma__i/(rho*t[i+1]))/(sqrt(Pi)*Q*R)))*C__i[i]/V__r;
    C__i[i+1] := C__i[i]+60*dC
  end do;
  return t, C__i
end proc:

>	t, C := CC(C__0, Q, V__r, m__b, rho, R, Gamma__i)

$t, C := Vector(4, {(1) = ` 1 .. 360 `*Vector[column], (2) = `Data Type: `*anything, (3) = `Storage: `*rectangular, (4) = `Order: `*Fortran_order}), Vector(4, {(1) = ` 1 .. 360 `*Vector[column], (2) = `Data Type: `*anything, (3) = `Storage: `*rectangular, (4) = `Order: `*Fortran_order})$

(1)

>

normalisatie := proc (C__i, C__0)
  local Z, i;
  Z := Vector(360, 0);
  for i to numelems(Z) do
    Z[i] := C__i[i]/C__0
  end do;
  return Z
end proc:

integraal := proc (t, r)
  local Integraal, i; # Change integraal into Integraal to avoid conflicts with the name of the procedure
  Integraal := 0;
  for i to numelems(t)-1 do
    Integraal := Integraal+((1/2)*r[i+1]+(1/2)*r[i])*(t[i+1]-t[i])
  end do:
  return Integraal
end proc:

optimalisatie := proc (t__ex, c__ex, C__0, Q, V__r, m__b, rho, R, Gamma__i_min, Gamma__i_max)
  local Gamma__i, t__sim, C__i, int__sim, int__ex, C__i_min, C__i_max, C__i0_min, C__i0_max, C__i0, int__sim_min, int__sim_max, i;
  local gamma__i_min, gamma__i_max;   # As gamma__i_min and Gamma__i_max are arguments of optimalisatiea
                                      # they cannot be assigned within this procedure.
  gamma__i_min := copy(Gamma__i_min): # what I understand
  gamma__i_max := copy(Gamma__i_max): # what I understand

  Gamma__i     := (1/2)*gamma__i_min+(1/2)*gamma__i_max;
  t__sim, C__i := CC(C__0, Q, V__r, m__b, rho, R, Gamma__i);
  int__sim     := integraal(t__sim, C__i);
  int__ex      := integraal(t__ex, c__ex);

if true then
  i := 0: # You probably missed to initialize i
  while i < 10 and 1/10 < abs(int__sim-int__ex) do
    Gamma__i := (1/2)*gamma__i_min+(1/2)*gamma__i_max;
    t__sim, C__i_min := CC(C__0, Q, V__r, m__b, rho, R, gamma__i_min);
#print(`-----`, 'C__i_min'=C__i_min[1..5]^+);
    t__sim, C__i_max := CC(C__0, Q, V__r, m__b, rho, R, gamma__i_max);
#print(`-----`, 'C__i_min'=C__i_max[1..5]^+);
    t__sim, C__i     := CC(C__0, Q, V__r, m__b, rho, R, Gamma__i);
    C__i0_min        := normalisatie(C__i_min, C__0);
    C__i0_max        := normalisatie(C__i_max, C__0);
    C__i0            := normalisatie(C__i, C__0);
    int__sim_min     := integraal(t__sim, C__i0_min);
    int__sim_max     := integraal(t__sim, C__i0_max);
    int__sim         := integraal(t__sim, C__i0);

print('(int__sim-int__ex)*(int__sim_max-int__ex)' = (int__sim-int__ex)*(int__sim_max-int__ex));
    if 0 < (int__sim-int__ex)*(int__sim_max-int__ex) then
      gamma__i_max := Gamma__i;
    else
      gamma__i_min := Gamma__i;
    end if:
    i := i+1:
  end do;
end if:

  return Gamma__i
end proc:

>	Gamma__i_min := 0: Gamma__i_max := 10: # You missed to initialize this variable # Note that (int__sim-int__ex)*(int__sim_max-int__ex) keeps a constant value # all along the computations Gamma__i := optimalisatie(T__ex, Cl__ex, C__0, Q, V__r, m__b, rho, R, Gamma__i_min, Gamma__i_max)

(2)

>

Download A_few_corrections.mw

A few solutions...

Answered: mmcdara 7891

October 22 2023

1 0

It is likely that a lot of people will provide you different methods to tackle your problem.
In the meantime, here are some answers to your question:

Method 1: to use in the case S contains a two vectors, each of the form (numeric)*x + (numeric)), returns the coefficients of f in the basis S (in case S is not abasis look at the end of the attached file).
Method 2: same restriction as Method 1, checks if S is a basis.
Method 3: same restriction and same purpose as Method 2, using LinearAlgebra:-Basis a can be easily extended to a set of N N-dimensional vectors.

>

restart:

>	S := {x+4, 3x-7}: f := -5x + 10:

>	# Method 1: (constructive method which gives the coefficients try solve(identity(a[1]S[1]+a[2]S[2]=f, x), [a[1], a[2]])[]; check = eval(a[1]S[1]+a[2]S[2] - f, %); catch: printf("The vectors in set S are not independent") end try;

(1)

>	# Method 2: # Let's say U is the Unity "1" SU := map(s -> add([selectremove(has, s, x)] *~ [1, U]), S); # If SU = 0 iif x=0 and U=0 the two vectors of S are independent, so # f can be rewritten as a linear combination of both of them. solve(SU);

(2)

>

# Method 3:
# Use of LinearAlgebra:-Basis: if the output of this function contains as many
# vectors has S, then the vectors of S form are linearly independent and
# f can be rewritten as a linear combination of both of them.

SU := map(s -> <[selectremove(has, s, x)]>, S);
LinearAlgebra:-Basis([SU[]]);

is(numelems(S)=numelems(%));

SU := {Vector(2, {(1) = x, (2) = 4}), Vector(2, {(1) = 3*x, (2) = -7})}

[Vector(2, {(1) = x, (2) = 4}), Vector(2, {(1) = 3*x, (2) = -7})]

(3)

>

# Method 3: a counter example

SC := {x+4, 2*x+8}:
SU := map(s -> <[selectremove(has, s, x)]>, SC);
LinearAlgebra:-Basis([SU[]]);

# Note that Method 1 doesn't finding a solution means the two vectors of S are
# not independent.

solve(identity(a[1]*SC[1]+a[2]*SC[2]=f, x), [a[1], a[2]])[];
try
  solve(identity(a[1]*SC[1]+a[2]*SC[2]=f, x), [a[1], a[2]])[];
  check = eval(a[1]*SC[1]+a[2]*SC[2] - f, %);
catch:
  printf("The vectors in set S are not independent")
end try;

SU := {Vector(2, {(1) = x, (2) = 4}), Vector(2, {(1) = 2*x, (2) = 8})}

The vectors in set S are not independent

>	# And probably a lot of other methods can be used

Download A_few_methods.mw

Some variations around this theme...

Answered: mmcdara 7891

October 22 2023

1 0

It's interesting to know that Statistics:-LinearFit can produce a lot of usefull outputs (see the corrresponding help page).
In the attached file (developed with Maple 2015) I use the special form output=solutionmodule.
All the statistics generated are displayed and you could find some of them very useful.

More specifically:

leastsquaresfunction corresponds to your model P,
residuals corresponds to your line err:=actual[i]-model.

In addition to that, the attached file proposes another way to display the results.

Remarks:

If you are only interested in printing the predictions and the residuals, just do that

P, residues := LinearFit([1,x], t, actual, x, output=[leastsquaresfunction, residuals])[]:

print('model' = P); 

printf("t    Actual P  Model P  Error\n");
for i from 1 to n do
  printf("%2.1f %7.4f% 10.4f% 9.4f\n", t[i], actual[i], actual[i]-residues[i], residues[i]);
end do:

# see at the end of the attached file

The indentation I used in the attached file is to help you understand how the T tables are constructed (type help(DocumentTools:-Layout:-Cell) in your worksheet to get the corresonding help page).
Note that it may be that in more recent versions of Maple, LinearFit may have an 'embed/embedded' option to replace the quite lenghty way I used to build and display these T tables (something to verify, if you have Maple > 2018, look to Statistics:-DataSummary to understand what I mean).
As an error occured in your loop, an wrong value of RMSE is displayed (see the attached file).
An alternative form to LinearFit([1, x], ...) is Fit(a+b*x, ...) (see the attached file).

Variations.mw

A proposition for Maple 2015...

Answered: mmcdara 7891

October 16 2023

1 0

Yellow highlighted fields have to be adjusted to get the desired rendering

>

restart

>	kernelopts(version)

(1)

>	with(plots):

>	f := sin(x*y):

>

d := densityplot(f, x=-Pi..Pi, y=-Pi..Pi, axes=boxed, colorstyle=HUE, style=patchnogrid, size=[400, 400]):

fmin := -1: # minimum of f over the plotting domain
fmax := +1: # maximum of f over the plotting domain

s := display(
  densityplot(y, x=0..1,y=0..1, axes=none, colorstyle=HUE, style=patchnogrid, size=[80, 400]),
  seq(textplot([1, h, fmin*(1-h)+fmax*h], align=right), h=0..1, 0.1)
):

DocumentTools:-Tabulate(
  [d, s],
  width=40, weights=[5, 1]
)

>

Download With_Maple_2015.mw

Your example: Your_example_with_Maple_2015.mw

Your code doesn't work with Maple 20...

Answered: mmcdara 7891

October 15 2023

2 2

Your code doesn't work with Maple 2015, what version do you use?
Here is a simple numerical scheme to solve your ode (which is not a delayed ode in the classical sense as the relay depends on x).

For the 2 first plot I did not use the "delaymax=1.7" condition:

The first plot helps verifying that the space step dx is small enough.
The 2nd plot is an extension over the range x=0..10.

For the 3rd plot I interpreted the "delaymax=1.7" condition as

x-(x/2) > 1.7  ===> ode = diff(y(x),x)=1-2*y(x-1.7)^2

Is it right?
If it is so, and if I made no errors in my code, you will see a major difference with the 2nd plot.

@Preben Alsholm
The fact my 2nd plot is identical to yours means that Maple doesn't correctly account for the "delaymax=1.7" condition.
This conclusion is confirmed by the "Quick check of the solution" for x=3, 5 and 10.
Note that "my" scheme correctly handles this "delaymax=1.7" condition.

I suspect a Maple bug in the resolution of delayed odes when the delay depends on the independent variable. It might be worth checking this out before possibly submitting an SCR.

>

restart

>	kernelopts(version)

(1)

>	ode:=diff(y(x),x)=1-2*y(x/2)^2; ics := y(0) = 2;

>	y3:= dsolve({ics, ode},numeric, delaymax = 1.7);

(2)

>	# A simple numerical scheme with x step dx N := 100: Y := Array(0..N): Y[0] := 2: dx := 0.01: for n from 1 to N do Yhalf := `if`(n::even, Y[n/2], (Y[(n+1)/2]+Y[(n+1)/2-1])/2): Y[n] := Y[n-1] + dx(1-2Yhalf^2) end do: p01 := plot([seq([n*dx, Y[n]], n=0..N)], color=red):

>	# The same simple numerical scheme with x step dx/10 N := 1000: Y := Array(0..N): Y[0] := 2: dx := 0.001: for n from 1 to N do Yhalf := `if`(n::even, Y[n/2], (Y[(n+1)/2]+Y[(n+1)/2-1])/2): Y[n] := Y[n-1] + dx(1-2Yhalf^2) end do: p001 := plot([seq([n*dx, Y[n]], n=0..N)], color=blue):

>	# Comparison: plots:-display(p01, p001)

>

# Going further

N    := 10000:
Y    := Array(0..N):
Y[0] := 2:
dx   := 0.001:
for n from 1 to N do
  Yhalf := `if`(n::even, Y[n/2], (Y[(n+1)/2]+Y[(n+1)/2-1])/2):
  Y[n] := Y[n-1] + dx*(1-2*Yhalf^2)
end do:

p0 := plot([seq([n*dx, Y[n]], n=0..N)], color=red, legend="No delaymax"):
plots:-display(p0);

>	# Quick check of the solution for x=3 (then x/2 = 1.5 < __delaymax): __delaymax := 1.7: x_check := 3; n := round(x_check/dx): dY := (Y[n]-Y[n-1])/dx; n_delaymax := round(n/2); Y_delaymax := Y[n_delaymax]; dY = 1-2*Y_delaymax^2;

(3)

>	# Quick check of the solution for x=5 (then x/2 = 2.5 > __delaymax): x_check := 5; n := round(x_check/dx): dY := (Y[n]-Y[n-1])/dx; n_delaymax := round(n-__delaymax/dx); Y_delaymax := Y[n_delaymax]; dY = 1-2*Y_delaymax^2;

(4)

>	# Quick check of the solution for x=10 (then x/2 = 5 > __delaymax): x_check := 10; n := round(x_check/dx): dY := (Y[n]-Y[n-1])/dx; n_delaymax := round(n-__delaymax/dx); Y_delaymax := Y[n_delaymax]; dY = 1-2*Y_delaymax^2;

(5)

>

# Acount for "delaymax=1.7"

N     := 10000:
Y     := Array(0..N):
Y[0] := 2:
dx    := 0.001:
#first := 0:
for n from 1 to N do
  __delay := n*dx/2;
  if __delay < __delaymax then
    Yhalf := `if`(n::even, Y[n/2], (Y[(n+1)/2]+Y[(n+1)/2-1])/2):
  else
    #if first = 0 then first := n end if:

    xprec := n*dx - __delaymax;
    nprec := floor(xprec/dx):
#print('nprec'=nprec);
    omega := xprec/dx-nprec;
    Yhalf := (1-omega)*Y[nprec]+omega*Y[nprec+1]
  end if:
  Y[n] := Y[n-1] + dx*(1-2*Yhalf^2)
end do:

p1 := plot([seq([n*dx, Y[n]], n=0..N)], color=blue, legend=typeset('delaymax'=__delaymax)):

plots:-display(p0, p1)

>	# Quick check of the solution for x=3 (then x/2 = 1.5 < __delaymax): __delaymax := 1.7: x_check := 3; n := round(x_check/dx): dY := (Y[n]-Y[n-1])/dx; n_delaymax := round(n/2); Y_delaymax := Y[n_delaymax]; dY = 1-2*Y_delaymax^2;

(6)

>	# Quick check of the solution for x=5 (then x/2 = 2.5 > __delaymax): x_check := 5; n := round(x_check/dx): dY := (Y[n]-Y[n-1])/dx; n_delaymax := round(n-__delaymax/dx); Y_delaymax := Y[n_delaymax]; dY = 1-2*Y_delaymax^2;

(7)

>	# Quick check of the solution for x=10 (then x/2 = 5 > __delaymax): x_check := 10; n := round(x_check/dx): dY := (Y[n]-Y[n-1])/dx; n_delaymax := round(n-__delaymax/dx); Y_delaymax := Y[n_delaymax]; dY = 1-2*Y_delaymax^2;

(8)

>

Download A_simple_scheme_delaymax.mw

Here is a quick check of the solution error
A_simple_scheme_delaymax_add_on.mw

Why integrating over -oo..+oo? And a way...

Answered: mmcdara 7891

October 12 2023

1 1

The integrand (10)vanishes extremely fast far from 0:

eval((10), t=2)
                                       -101
                    8.74207704900475 10    
eval((10),  t=5)
                                       -1450
                    9.27406195293248 10

and is symmetric.

If you are really interested in getting an approximation of the integral look at this

ff := (11):
L := [seq(0.2..2.0, 0.2)]:
for l in L do
  printf("Range = %1.1f..%1.1f  Int = %a\n", -l, l, 2*evalf(Int(ff, t=0..l)));
end do;

Range = -0.2..0.2  Int = .953869585255756e-1
Range = -0.4..0.4  Int = .998942521814238e-1
Range = -0.6..0.6  Int = .999002157052540e-1
Range = -0.8..0.8  Int = .999002158581252e-1
Range = -1.0..1.0  Int = .999002158581254e-1
Range = -1.2..1.2  Int = .999002157052540e-1
Range = -1.4..1.4  Int = .999002158581252e-1
Range = -1.6..1.6  Int = .999002158581252e-1
Range = -1.8..1.8  Int = .999002158581252e-1
Range = -2.0..2.0  Int = .999002158581252e-1

You have an almost true value (error ~ 1e-15) as soon as the half integration range goes beyond than 1.4.
Given that most of the integration methods do not accept a value of Digitslarger than 15, it seems useless to me to expect a more accurate value of the integral.

Now if you really want to integrate over -oo..+oo for some reason, I propose you to transform this integration range into a finite one.
A classical transformation is t = arctanh(tau) (the integration range is now tau=-1..+1).
The result is almost instaneous

with(IntegrationTools):
J    := Int(ff, t=-infinity..+infinity):
Jtau := Change(J, t=arctanh(tau), tau):
Jtau := op(1, Jtau)*Int(GetIntegrand(Jtau), tau=GetRange(op(-1, Jtau)), method=_Gquad):

Digits := 15:
CodeTools:-Usage(evalf(Jtau));
memory used=6.23MiB, alloc change=0 bytes, cpu time=67.00ms, real time=90.00ms, gc time=0ns
                       0.0999002158581254

OverflowError_mmcdara.mw

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

Ask a Question

Create a Post

7891 Reputation

22 Badges

MaplePrimes Activity

These are answers submitted by mmcdara

At least two ways...

One Way...

I didn't read your 3 self-replies but......

ImageTools ?...

Statistics:-Trim seems to do what you wa...

varphi_c_c and var_phi_f not define......

What a shame you changed the left bc !...

NewtonsMethod's help page:The Newton...

Use ListTools:-Search...

Without even using maplemint one can see...

A few solutions...

Some variations around this theme...

A proposition for Maple 2015...

Your code doesn't work with Maple 20...

Why integrating over -oo..+oo? And a way...

Save this setting as your default sorting preference?

Ask a Question

Create a Post

Generating PDF…

Save this setting as your default sorting preference?
Note: You can change your preference any time in your account settings
Don't show this again