Plimpton was a collector of ancient mathematical manuscripts, not a Babylonian mathematician. See here.

acer

As I mentioned, it matters whether the data are in lists, arrays, or Vectors. You have Cd as a list, and S and V as vectors (not Vectors).

Also, the names of the variables have to be names. You had them passed in as list and vectors.

> restart:

> Cd := Vector([.686, .693, .702, .714, .728, .745, .764,
> .785, .594, .597, .601, .607, .614, .621, .63, .641,
> .545, .546, .549, .553, .557, .562, .566, .574, .514,
> .515, .518, .52, .523, .526, .53, .535, .494, .495,
> .496, .498, .5, .503, .504, .505, .479, .48, .481, .482,
> .484, .485, .488, .49]):

> S := Vector(10^3*[.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, .5, 1,
> 1.5, 2, 2.5, 3, 3.5, 4, .5, 1, 1.5, 2, 2.5, 3, 3.5, 4,
> .5, 1, 1.5, 2, 2.5, 3, 3.5, 4, .5, 1, 1.5, 2, 2.5, 3,
> 3.5, 4, .5, 1, 1.5, 2, 2.5, 3, 3.5, 4]):

> V := Vector([40, 40, 40, 40, 40, 40, 40, 40, 60, 60,
> 60, 60, 60, 60, 60, 60, 80, 80, 80, 80, 80, 80, 80, 80,
> 100, 100, 100, 100, 100, 100, 100, 100, 120, 120, 120,
> 120, 120, 120, 120, 120, 140, 140, 140, 140, 140, 140,
> 140, 140]):

> W := Statistics:-Fit(a+b*s+c*v+d*s^2+e*s*v+f*v^2,
>                      Matrix([S, V]), Cd, [s, v]);

W := 0.902488010204080870 + 0.0000229827097505673132 s
 
                                                         -8  2
     - 0.00678694515306121904 v + 0.172619047619042866 10   s
 
                              -6                                 2
     - 0.226020408163267168 10   s v + 0.0000278906249999999783 v

acer

As I mentioned, it matters whether the data are in lists, arrays, or Vectors. You have Cd as a list, and S and V as vectors (not Vectors).

Also, the names of the variables have to be names. You had them passed in as list and vectors.

> restart:

> Cd := Vector([.686, .693, .702, .714, .728, .745, .764,
> .785, .594, .597, .601, .607, .614, .621, .63, .641,
> .545, .546, .549, .553, .557, .562, .566, .574, .514,
> .515, .518, .52, .523, .526, .53, .535, .494, .495,
> .496, .498, .5, .503, .504, .505, .479, .48, .481, .482,
> .484, .485, .488, .49]):

> S := Vector(10^3*[.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, .5, 1,
> 1.5, 2, 2.5, 3, 3.5, 4, .5, 1, 1.5, 2, 2.5, 3, 3.5, 4,
> .5, 1, 1.5, 2, 2.5, 3, 3.5, 4, .5, 1, 1.5, 2, 2.5, 3,
> 3.5, 4, .5, 1, 1.5, 2, 2.5, 3, 3.5, 4]):

> V := Vector([40, 40, 40, 40, 40, 40, 40, 40, 60, 60,
> 60, 60, 60, 60, 60, 60, 80, 80, 80, 80, 80, 80, 80, 80,
> 100, 100, 100, 100, 100, 100, 100, 100, 120, 120, 120,
> 120, 120, 120, 120, 120, 140, 140, 140, 140, 140, 140,
> 140, 140]):

> W := Statistics:-Fit(a+b*s+c*v+d*s^2+e*s*v+f*v^2,
>                      Matrix([S, V]), Cd, [s, v]);

W := 0.902488010204080870 + 0.0000229827097505673132 s
 
                                                         -8  2
     - 0.00678694515306121904 v + 0.172619047619042866 10   s
 
                              -6                                 2
     - 0.226020408163267168 10   s v + 0.0000278906249999999783 v

acer

The help-page ?Fit says that the second argument, "X", should be the independent data. For several independent variables, that data should be in a Matrix.

As you had it originally, the x, y, and z data were all being supplied as separate arguments. So Maple was trying to interpret the z array as the fourth parameter which is supposed to be designate the names of the independent variables.

The solution is to combine x and y into that single Matrix of independent data. See my response above.

Double check that it is oriented correctly, with x and y as the two columns of the 48x2 Matrix. You mentioned that x and y were "arrays". How they may be joined, to make a single Matrix with x and y as the two columns, will differ according to whether x and y are lists, arrays, or Vectors. For example,

> x:=[a,b]: y:=[c,d]:
> Matrix([x,y])^%T;
                                   [a    c]
                                   [      ]
                                   [b    d]
 
> x:=array(1..2,[a,b]): y:=array(1..2,[c,d]):
> Matrix([[x],[y]])^%T;
                                   [a    c]
                                   [      ]
                                   [b    d]
 
> x:=Vector([a,b]): y:=Vector([c,d]):
> Matrix([x,y]);
                                   [a    c]
                                   [      ]
                                   [b    d]

acer

The help-page ?Fit says that the second argument, "X", should be the independent data. For several independent variables, that data should be in a Matrix.

As you had it originally, the x, y, and z data were all being supplied as separate arguments. So Maple was trying to interpret the z array as the fourth parameter which is supposed to be designate the names of the independent variables.

The solution is to combine x and y into that single Matrix of independent data. See my response above.

Double check that it is oriented correctly, with x and y as the two columns of the 48x2 Matrix. You mentioned that x and y were "arrays". How they may be joined, to make a single Matrix with x and y as the two columns, will differ according to whether x and y are lists, arrays, or Vectors. For example,

> x:=[a,b]: y:=[c,d]:
> Matrix([x,y])^%T;
                                   [a    c]
                                   [      ]
                                   [b    d]
 
> x:=array(1..2,[a,b]): y:=array(1..2,[c,d]):
> Matrix([[x],[y]])^%T;
                                   [a    c]
                                   [      ]
                                   [b    d]
 
> x:=Vector([a,b]): y:=Vector([c,d]):
> Matrix([x,y]);
                                   [a    c]
                                   [      ]
                                   [b    d]

acer

Sorry, I answered this out of order.

acer

Sorry, I answered this out of order.

acer

It's not a great improvement, as it just produces a piecewise of a comparison of piecewises. One could get similar behaviour with the more straightforward (original) application of `min` and the introduction of `unapply`. Ie,

> f1:=x->piecewise(x>0,cos(x),1);
                    f1 := x -> piecewise(0 < x, cos(x), 1)

> f2:=x->piecewise(x>0,sin(x),-1);
                    f2 := x -> piecewise(0 < x, sin(x), -1)

> f3:=unapply(min(f1(x),f2(x)),x);

   f3 := x -> min(piecewise(0 < x, cos(x), 1), piecewise(0 < x, sin(x), -1))
 
> f3(2);
                                    cos(2)

That seems just as easy as does the following, given that one started with a request about using `min`.

> f3:=unapply(piecewise(f1(x)<f2(x),f1(x),f2(x)),x);

f3 := x -> piecewise(
 
    piecewise(0 < x, cos(x), 1) < piecewise(0 < x, sin(x), -1),
 
    piecewise(0 < x, cos(x), 1), piecewise(0 < x, sin(x), -1))

> f3(2);
                                    cos(2)

The original poster might be satisfied with using `unapply` on the `min` call, without even any combining of piecewises at all.  Simply using `unapply` alone might serve all his needs.

What I am now wondering is whether one can get Maple to actually combine this slightly harder example (with sin and cos) into a single piecewise. Such a simplified result would evaluate faster, or be simpler to subsequently manipulate. Neither `combine`, `simplify`, or the undocumented PiecewiseTools:-Simplify managed it, for my example.

> f4 := unapply(piecewise(x>0,min(sin(x),cos(x)),-1),x);

             f4 := x -> piecewise(0 < x, min(cos(x), sin(x)), -1)

acer

It also helps if the specific tasks in the "use cases" are not all chosen purely according to what the product creators can imagine. Having a really good mechanism by which users and potential users can provide input into the set of tasks is important.

acer

That example also worked out using `simplify` instead of `combine`.

But what about this one?

f1:=x->piecewise(x>0,cos(x),1);

f2:=x->piecewise(x>0,sin(x),1);

acer

The number of views of a blog posting used to be shown here, beside the entry.

After a year or so of mapleprimes (the long "beta"?) that functionality was removed. I once posted about that, and the response (by Will? I can't find it now) was that someone would look into it.

acer

`add` is faster than `sum` for this sort of thing. It was about 2.5 times faster to compute p(2000) using `add` rather than `sum`, for example.

Writing a truly recursive procedure `s`, with option remember, is also faster than the above `sum` code (but not as fast as with `add`). But it could help, if you intend on computing some sorts of very long sets of increasing values with it.

s := proc(n)
local k;
option remember;
    if n = 1 or n = 2 then return 1
    else for k from 2 to n do
            s(k) := 2*add(s(i)*s(k - i), i = 1 .. k - 2) + s(k - 1)
        end do
    end if;
    s(n)
end proc:

So, once s(2000) is computed then s(1000) is computed near instantaneously, as it only requires a remember-table lookup.

I didn't bother considering whether there is any closed form of any of this.

acer

`add` is faster than `sum` for this sort of thing. It was about 2.5 times faster to compute p(2000) using `add` rather than `sum`, for example.

Writing a truly recursive procedure `s`, with option remember, is also faster than the above `sum` code (but not as fast as with `add`). But it could help, if you intend on computing some sorts of very long sets of increasing values with it.

s := proc(n)
local k;
option remember;
    if n = 1 or n = 2 then return 1
    else for k from 2 to n do
            s(k) := 2*add(s(i)*s(k - i), i = 1 .. k - 2) + s(k - 1)
        end do
    end if;
    s(n)
end proc:

So, once s(2000) is computed then s(1000) is computed near instantaneously, as it only requires a remember-table lookup.

I didn't bother considering whether there is any closed form of any of this.

acer

Do you mean this one, attributed to Ramanujan? (Using natural logarithm, so adjusted by factor of ln(10.)).

> ff := n*ln(n) - n + ln(n*(1+4*n*(1+2*n)))/6 + ln(Pi)/2;

        ff := n ln(n) - n + 1/6 ln(n (1 + 4 n (1 + 2 n))) + 1/2 ln(Pi)

> evalf[30](evalf[5000](eval(ff,n=3000)/ln(10.)));
                        9130.61798107450627025514189604

> evalf[30](ln(evalf[5000](3000!))/ln(10.));
                        9130.61798107450628141828801479

> evalf[30](evalf[5000](eval(ff,n=2^32)/ln(10.)));
                                                        11
                     0.395079669763461126642613649132 10

> trunc(%);
                                  39507966976

So, the above is indicating 39507966976 decimal digits in (2^32)!.

acer

Do you mean this one, attributed to Ramanujan? (Using natural logarithm, so adjusted by factor of ln(10.)).

> ff := n*ln(n) - n + ln(n*(1+4*n*(1+2*n)))/6 + ln(Pi)/2;

        ff := n ln(n) - n + 1/6 ln(n (1 + 4 n (1 + 2 n))) + 1/2 ln(Pi)

> evalf[30](evalf[5000](eval(ff,n=3000)/ln(10.)));
                        9130.61798107450627025514189604

> evalf[30](ln(evalf[5000](3000!))/ln(10.));
                        9130.61798107450628141828801479

> evalf[30](evalf[5000](eval(ff,n=2^32)/ln(10.)));
                                                        11
                     0.395079669763461126642613649132 10

> trunc(%);
                                  39507966976

So, the above is indicating 39507966976 decimal digits in (2^32)!.

acer