@Gibberish123 I see. So for your (n,e) RSA scheme you'll need to generate a number num from the plaintext string such that gcd(num,n)=1 , and 0<=num<n .

Once you can do that, the encryption/decryption might be as follows:

restart:

n := 17;
                                       n := 17

L := numtheory[lambda](n);
                                       L := 16

e := 5;
                                       e := 5

evalb( e < L ); # a requirement 
                                        true

evalb( gcd(e, L) = 1); # a requirement
                                        true

d := 1/e mod L;
                                       d := 13

num := 10;  # a number generated from the plaintext string
                                       num := 10

c := num^e mod n;  # the encrypted number
                                        c := 6

c^d mod n;  # decrypting back to num
                                          10

In Maple, for a large n, it is more efficient to use the following command for modular exponentiation (which avoids explicit computation of num^e which happens when executing num^e mod n ).

modp(Power(num,e), n); # efficient modular exponentiation
                                           6

modp(Power(c,d), n); # efficient modular exponentiation  
                                           10

So given a plaintext ascii string you have to use an n, as well as figure out a way to convert from string to number, and pad, so that (at least) the following conditions hold:

evalb( gcd(num,n)=1 and num<n );
                                         true

@tomleslie It looks to me like your suggestion [edited to remove suggestion to divide by N] is the composite trapezoidal rule (or the average of the left and right Riemann sums, but not a mid-point Riemann sum).

It's not a wrong approach. But quite often one might attain a more accurate result with a higher order interpolation scheme (ie. higher than linear). Of course "quite often" relates to the smoothness of well-behavedness of the underlying function approximated by the data.

The OP has not mentioned accuracy or performance, unfortunately.

@Gibberish123 Correct, I did not implement RSA encryption/decryption for you. Are you hoping for someone to implement a secure padding scheme such as this? By the way, is this course work?

@Markiyan Hirnyk Your previous comments to your own answer above had,

int(c[2]*(diff(c[1], v)), v = 0 .. 9);

instead of,

int(c[2]*(diff(c[1], v)), v = 1 .. 6);

which you now use. My reply to you is that your initial upper end-point range for the parameter (ie, 9), while integrating, was invalid, which I would have thought was obvious in my previous response. You have not shown how you got "6" here, either.

Let's hope that the OP's data represents a mathematical funcion (one y value only for each x value), and not a more general curve.

@Markiyan Hirnyk I posted an Answer to the OP's question, not a Reply to your Answer. The OP did not supply data, as far as I have noticed, and as I was not replying to your Answer I see no special reason to use the same example data as you have.

And I have also used different interpolating commands from you, yes. I don't think that BSplineCurve is necessarily the right thing to use: there is a reason why the 3rd entry in the list it returns may not be a range (for the parameter denoting x(v) and y(v) ) that extends the curve as a mathematical function y(x) over all the independent data. A B-spline is a beast of another color, and one should be extra careful if trying to force it to cover the full range of the (supplied) independent data if a function (mathematical sense) is desired.

By "independent range as returned by BSplineCurve" of course I mean a range for the parameter (not the independent data variable).

Download bsplinething.mw

@AmusingYeti I find `tools/genglobal` pretty useful, when I want to generate an unassigned global name. (It gets passed the base of the name.) Sometimes I use PiecewiseTools:-Flatten. But usefulness is in the eye of the beholder.

@sand15 In Maple 2015.2 I had to put the interface calls in separate Execution Groups in order to have it work, using a Worksheet. (That seems fixed in Maple 2016.0, btw.)

Download writetoexample.mw

@DSkoog I think that the explanation you've given about why it does not work is not right. For example, try using `printf` after calling `writeto` to redirect. The `printf` command does not produce "assignable returned output", but its output can be redirected.

No, the problem is rather that `showstat` makes use of an internal routine that calls `fprintf` with an (essentially) preset name. But this can be undone. I'll put one way to do it in an Answer.

Of course, it's still possible that the OP doesn't especially want or need line numbers, and simply using `print` (after setting verboseproc) instead of `showstat` might well be adequate for him.

I changed the inlined URLs to the original authors' webpages, since there is no evidence that the poster has those authors' permission to copy any of the materials up to this site.

Applying the evalf command to such a RootOf will cause Maple to use fsolve.  (This doesn't you all control over the various options to the fsolve command, though.)

Another way is to fix the hue layer of the color Array in the plot structure, after the fact.
 

Download coolhot2.mw

@Rouben Rostamian  Since the OP appears to have Maple 18, then the commands would be,

map(fnormal, M.v);

simplify(map(fnormal, M.v), zero);

map(fnormal, v);

simplify(map(fnormal, v), zero);

I'm not sure whether this might confuse the OP, but the smallest eigenvalue (in absolute value) of the given Matrix is not zero. It is small in absolute value, but not zero. So it's not clear whether he would prefer to find the eigenvector associated with that, or the singular vector (which is what NullSpace computes here). I note also that for higher working precision (Digits>12 ?) the numerical rank will compute as 4 and NullSpace will return empty.

@John Fredsted Fooling around and learning by experimentation is always good. Nobody was born knowing maple.

My attachment won't serve as oracle for other different examples. Perhaps the key thing to remember is that the commands zip, map (and map [n] variants) and elementwise operators are different. There is often overlap in their functionality, but no simple correspondence. 

@John Fredsted It seems to me that quite a bit of your difficulty in this example is due to misconceptions about what elementwise operators are supposed to do, and what the syntax means.

Your original map call was,

    map(x -> A . x,LM)

and one valid elementwise operator equivalent is,

    (x -> A . x)~(LM)

since the original operator in your question is x->A.x and not the `.` operator.

It may be that, conceptually, you were only considering that LM is a "container", and overlooking that it really does matter that A is also a "container". But that matters, in the attempted A .~ LM you tried. Bear in mind that your goal was a computation which does not act elementwise on A, so plain A would not be an argument to the successful elementwise operator call. Your attempt A .~ LM is the infix variant of the prefix call `.`~(A,LM) and so it's quite logical that would attempt to use both A and LM in an elementwise manner.

As for the map2 example I gave, it might help a little to think of map as map[1], and map2 as map[2]. You wanted to treat only LM (and not A) in an elementwise manner. The map[1] and map[2] commands allow you to have just one of the arguments be treated elementwise. And that extends to map[n] more generally,

    `*`~( [2,3], [a,b], [x,y] );

                               [2 a x, 3 b y]

    map[1](`*`, [2,3], [a,b], [x,y] );

                     [2 [a, b] [x, y], 3 [a, b] [x, y]]

    map[2](`*`, [2,3], [a,b], [x,y] );

                     [[2, 3] a [x, y], [2, 3] b [x, y]]

    map[3](`*`, [2,3], [a,b], [x,y] );

                     [[2, 3] [a, b] x, [2, 3] [a, b] y]

I'll attach a sheet. I hope it helps clarify, rather than not.

elementwise.mw

@tomleslie On the help page for topic operators,elementwise in Maple 2016 I see, "When mixed container types are present the return type will be determined according to the following precedence: object, rtable, list, set."

And that explains why both [1,2,3]*~{4,5,6} and {4,5,6}*~[1,2,3] return a list. It also (correctly) indicates that elementwise multiplication of a Vector and a set returns a Vector.