Another way,

Download multiple_angle_reduction.mw

To assign to x,

   x := log[2](6);

Note the distinction between the exact symbolic result and the float-approximation.

log[2](6);
                                                                                        
                   ln(6)
                   -----
                   ln(2)

log[2](6.0);                                                                                      

                 2.584962501

What version of Maple are you using, and which platform (Operating System)?

restart;
kernelopts(version);

   Maple 2019.1, X86 64 LINUX, May 21 2019, Build ID 1399874

Optimization:-LPSolve(4*x1+5*x2+5*x3+2*x4,
                      {33*x1 + 49*x2 + 51*x3 + 22*x4 <= 120},
                      maximize, assume ={nonnegint},
                      depthlimit=10); 

          [13, [x1 = 2, x2 = 1, x3 = 0, x4 = 0]]

Optimization:-Maximize(4*x1+5*x2+5*x3+2*x4,
                       {33*x1 + 49*x2 + 51*x3 + 22*x4 <= 120},
                       assume=nonnegint, depthlimit=10);

          [13, [x1 = 2, x2 = 1, x3 = 0, x4 = 0]]

I get the same results using Maple 16.02 for 64bit Linux.

Here is one way to do that.
replaceid_example.mw

Here is another way, using readstat for the original query.
readstat_example.mw

I await the followup, "What I actually want to do is..."

If you want to have the return value be a procedure (or operator) then there's no need to demand that the name of its formal parameter be supplied to LinModel.

Note that by using CurveFitting:-LeastSquares rather than Statistics:-Fit the fitting model can be omitted from the call (as the former computes a linear model in that case).

Download CF.mw

Of course, you could still supply the name of the formal parameter to be used for the returned procedure (if you want, but there is no significant distinction -- it's just a dummy name).

I have also changed the type specification of parameter x in the definition of procedure LinModel from ::algebraic to ::name which is tighter (and more correct, IMO).

Download CF2.mw

It may have occurred to you that this a long-winded way to obtain functionality that is almost directly available from a stock Maple command. But perhaps you are trying to learn the ins and outs of packages, and this is merely a toy example. Or perhaps you had a coursework question to implement least squares regression to a linear model from scratch?

The AudioTools package was introduced in Maple 10 (2005). So it should work in your Maple 12.

restart;
with(AudioTools):

# A[6] 1760.00 Hz
A := Create(duration=2.0, rate=44100,
            x->evalhf(sin(x*2*Pi*1760.00/44100))):
Write(cat(kernelopts(homedir),"/mapleprimes/sampA.wav"), A):

# B[6] 1975.53 Hz
B := Create(duration=2.0, rate=44100,
            x->evalhf(sin(x*2*Pi*1975.53/44100))):
Write(cat(kernelopts(homedir),"/mapleprimes/sampB.wav"), B):

# A[4] 440.00 Hz
A440 := Create(duration=2.0, rate=44100,
            x->evalhf(sin(x*2*Pi*440.00/44100))):
Write(cat(kernelopts(homedir),"/mapleprimes/sampA440.wav"), A440):

As you can see this is very straightforward. Producing, say, B[4] = 493.88 Hz is done similarly.

And of course you could also write a 1-line procedure that took a frequency as an argument and generated the corresponding pure tone.

Using the App Centre link you gave (with its code from the year 2000 using writebytes, convert, and much Library level code) seems unnecessarily much more complicated, and quite possibly slower and less robust.

L1:=[a,b]:

`/`(op(L1));

                 a/b

L2:=[a,b,c,d]:

`/`(op(L2));

                   a
                 -----
                 b c d

It looks like you're trying to compute something simple (like, say, the min or max real root of some cubics). But you have not provided a clear description of your goal. And your worksheet contains weird unreferenced expressions and parameters, as if part of your inputs were copy&pastes.

Trying to deal with symbolic expressions representing roots (and which contain explicit radicals) by calling solve on a cubic with float coefficients will lead to numeric roundoff error upon subsequent floating point evaluation. That includes the case involving substituition for parameter sigma. One consequence is that the purely real root(s) may be hidden behind nonzero imaginary float artefacts. Even the fact that a cubic has at least one real root may be obscured by this unsound technique.

Here's my guess as to what you're trying to accomplish, using fsolve.

In the following attachment I break up the plotting in order to force use of the value of sigma where the discriminant (with respect to a) of the first cubic changes sign. This allows the curves of two of the "roots" to match up.

Download cposfsolvediscrim.mw

Here is an earlier attempt using fsolve, which did not force use of the value for sigma where the discriminant changed sign. Notice the hole in the curves where two of the "roots" to not quite match up.
Download cplotposfsolve.mw

Here is an attachment that plots all the roots (not just a>0), using indexed RootOfs.
Download cplot.mw

Here is a related way to obtain the plot of only the positive roots, using the indexed RootOfs. (This is slower than the above way, using fsolve, I believe.) 

Download cplotpos.mw

The very last 2D Input equation in subsection Projektioner is invalid (corrupted, in the sense that the stored base64 encoded .m represents a blob of Typesetting calls that are not validly displayable).

But I believe that the following attachment contains everything else, recovered. Please check.

recovered_ac.mw

(My attachment above was saved in Maple 2019.1. Just in case there's any issue, here also is the original attachment by the OP, with only the offending XML Equation manually removed from the .mw file. raw_edited_ac.mw )

[edited]
Note, sometimes when the GUI has collapsed everything to a single line then formatting can be recovered by doing the main menubar actions View->Sections->Collapse All Sections followed by View->Sections->Expand All Sections. For the OP's corrupted original that doesn't fix everything, as the invalid 2D Input instance makes the GUI go wrong still.

The problematic 2D Input instance is decoded here. errantTS.mw

If I attempt to form a similar invalid 2D Input typeset column Vector (with simply a minus sign in one entry) then the GUI indicates it's invalid but otherwise doesn't run amok. errant2D.mw So I don't know how to reproduce the bug. 

You're second to last line does t:=evalf(t[1]) but before that `t` is not something which can be indexed. So that line makes no sense.

And so what you're passing to fsolve is not a sensible expression.

Your Question is marked as Maple 2019, so I'll use that.

If I load the linkedlist module from a .mla Library Archive (including the one that resides within a workbook), or if I first savelib it to a .mla, then my output from your examples shows the long form linkedlist:-nil provided that I have the typesetting level set to standard.

If I toggle that level back to extended (ie. its original default for new users) then the output shows the short form nil only.

If I simply read the .mpl source then my output shows the short form nil regardless of typesetting level.

Perhaps this is the source of your problem.

nb. You can set the level as a GUI preference -- automatic across sessions. Or you can programmatically set it for an opened worksheet by issuing the command,
   interface('typesetting'=':-extended'):
in its own execution group.

nb. The level extended is the new default for new users. It behaves better than it did back when standard was the default. IMHO it may be generally best to use the default, unless there is some special cause.

I believe that it is not.

For a float Matrix the CharacteristicPolynomial command computes an unexpanded product, using the computed eigenvalues. (So it's mostly "ok" to compute the roots of that, but unnecessary since the Eigenvalues command computes that directly. It would be bad to expand the characteristic polynomial and then do numeric root-finding, because that is numerically less stable.)

What is also not a great idea is to compute the eigenvalues by doing numeric root-finding on the determinant of the characteristic matrix (which is what the OP's code does at one point), and which is what I suspect Carl is describing as unwise.

Additionally, if one happens to want singular values then utilize the SingularValues command. That can provide a numerically robust approach to PCA.

I'm not completely sure what form of answer you're looking for. Here's my guess as to what you may be after, given a polynomial system.

Download solve_polysys.mw

Here's my original Answer, which accomplished a similar thing in a rough, manual sort of way,

solveQ.mw

The commands in DocumentTools, such as DocumentTools:-GetProperty, are for use in query properties of Embedded Components. Those are quite different and separate from Maplets.

You cannot use DocumentTools:-GetProperty to check whether a Maplets:-Elements:-CheckBox is toggled. Those do not interact, since Embedded Components and Maplets provide quite separate functionality.

If you really do plan on using Maplets, then in order to learn to use Checkbox from the Maplets:-Elements package you might start by studying basic examples, eg. online here, here, and here. Or you can read the corresponding Help pages within your Maple itself.

Or are you trying to use Embedded Components, rather than Maplets?