@lcz I don't see how splitting the file into multiple files could possibly help.

What's the byte count of the large file? Even if it's 100 Mb, it'd easily fit in Maple's memory as, say, an array of strings, one string for each line.

@sursumCorda Christian's concluding Answer, essentially evala(Algfield(bSol))[3], is exact and symbolic. For this reason, I've promoted his Reply to an Answer and given it a vote up.

@vs140580 Are you literally asking how to apply the function x-> (x - xmin)/(xmax - xmin) (linear projection onto the unit interval) to each column of a matrix? I insist that you try this on your own and post the results here. If you can't do this, you haven't been learning from the many, many Answers I've written for you over the years. I'm not saying that you should be able to write the best possible code to do this task, but you should be able to come up with something.

@sand15 The issue is not caused by eval but rather by signum, for which there's a quite-elaborate and user-definable mechanism for evaluating signum(0). See ?signum.

You cannot hold the int command accountable for errors caused by symbolic substitutuons that you make after the int command is finished.

The definite integral of 0 over any space whatsoever for which integration can be defined is 0. Were it not so, integration wouldn't be a linear operator. If it's not a linear operator, the whole theory of integration falls apart.

Maple commonly expresses things in a sum-over-the-roots-of-some-polynomial form. I think this much more clearly shows the underlying structure of an expression than an array of explicit roots would. For those cases where the roots can be exactly specified, it's easy to convert to that form.

@Pi If M is a matrix (such as I defined above), then the values that you want can be accessed as M[i,j].

Yes, I'd say that it's a bug. Your graph G__0 is acyclic (confirmed both by GraphTheory:-IsAcyclic and visually), so the edges of its transistive reduction should be a subset of the edges of G__0. Here's G__0:

The ability to express these things (referring to this and your previous Posts using implicitplot3d) as implicit equations is mathematically "interesting", but I don't think that it's particularly useful for plotting. Much better 3d plots can usually be obtained from parametric representations.

@lcz If G is a directed acyclic graph (DAG), then its transistive reduction

1. is unique,
2. is a subgraph of G,
3. can be computed in polynomial time.

But if G has a directed cycle, then none of those 3 things are necessarily true.

@acer Nesting elementwise operators by folding index (which is a kinder, gentler variation of `?[]`) is a great idea. Here's what I came up with:

`&~`:= (f, n::nonnegint)-> foldr(index, f, `~`$n):

Usage example:

(convert &~ 2)(fasteners, unit_free)

@acer I'm sorry if you mentioned this in your worksheet; I didn't read it because I'm posting from my phone. I see now that you mentioned nested elementwise operators in your posted text. Again, sorry for not reading closely.

@Oliver K Your suggestion only returns the 1st list element, not the left sides of the equations. 

@mmcdara I think a DataFrame combines the best features of a spreadsheet, a matrix, and a table. Its underlying data structure is identical to your matrix, but the indexing is overloaded so that it's indexed by the odds from 1 to 49.

@Michael Although prime factorization isn't the most efficient way to do this, you were well on your way to discovering the simplest code to do it: the degree command:

p_log:= (n::integer, p::prime)-> degree(ifactor(n), ``(p)):

The key is the `` function symbol. It doesn't show in prettyprinted output, so it serves as a way to display output with "just" parentheses. But you can see it with lprint (a command that shows a "raw form" of output):

lprint(ifactor(24));
``(2)^3*``(3)

All I see is that you've defined (implicitly) a sequence of polynomials. Rings have nothing to do with it.