@Elisha I'm sorry, Elisha, but your code doesn't make sense to me, and I can't extract your equations from it. If you post a photo of your equations in standard mathematical form, I'd be able to work with that. I'd also need the initial conditions and  numeric values for all parameters.

What you are asking about is one of the most common operations in Maple, and you should be able to find thousands of Answered Questions about it if you search MaplePrimes. Also, read the help ?dsolve,numeric. The information on that help page can be overwhelming for a new user, so I recommend that you start reading in the examples section.

Here's an example. The process is really quite simple:
 

Download dsolve_rkf45.mw

For a linear recurrence of order greater than one with constant coefficients, a matrix-powering method with repeated squaring is by far the fastest method of evaluation for large values of the independent variable. This is the method used by rsolve(..., makeproc) for these recurrences.

Here's this method compared with evaluation of the closed form and a recursive procedure using memoization.
 

Download rsolve_makeproc.mw

This overwhelmingly superior performance of makeproc only applies to the specific type of recurrence mentioned in the first sentence.

I see that this OEIS entry has no Maple code. Perhaps you can add the above and bring glory to Maple, MaplePrimes, and yourself. I also see that the Mathematica code uses the closed form hard-coded. This is very shoddy programming, and that code should be updated.

Two reasons that a post may be deleted are duplication and illegibility. I saw that you had two recent Posts titled "a brief point of interest regarding the riemann zeta function". The first of these was illegible (much too small), and, of course, one was a duplicate. So, I deleted the first. This was after you posted this Question, so I guess that you had some earlier Post deleted also. I know nothing about this prior deletion.

The problem is that there are no closed-form derivatives for your hypergeom expressions. If I extract the four expressions from your procedure and then do

diff(hg1, d1);  diff(hg2, d1);  diff(hg3, d2);  diff(hg4, d2);

then all four return as unevaluated derivatives. That remains true if I supply all the numeric values for the constants that are specified by your procedure.

If you're willing to supply the numeric values for the constants, then you can use fdiff for numeric differantiation, like this:

GradOV:= (d1::complexcons, d2::complexcons, o::complexcons)-> map2(fdiff, OV, [$1..nargs], [args]):
GradOV(.1,.1,.1);
       [-0.0000134160704295650, -0.0000126237476161610, -0.0122287665536620]

@Kitonum You might as well just use Statistics:-Tally.

@brian bovril 

(remove~)~(`=`, P, 5);

Each ~ corresponds to one level deeper of nesting.

It's a great Question.

Using a procedure that returns a module as an object constructor has fallen into disfavor. The modern way is to replace your procedure and both modules with a single module that has option object. Here's a minimal working example of your example:

Point:= module()
option object;
local 
   x, y,
   ModuleApply::static:= ((xx, yy)-> Object(Point, _passed)),
   ModuleCopy::static:= proc(mi::Point, proto::Point, xx, yy, $)
      (mi:-x, mi:-y):= `if`(_npassed > 2, [xx,yy], [proto:-x, proto:-y])[]
   end proc,
   ModulePrint::static:= ((mi::Point)-> [mi:-x, mi:-y]),
   ModuleType::static:= (()-> true)
;
export
   `+`::static:= ((p1::Point, p2::Point)-> Point(p1:-x + p2:-x, p1:-y + p2:-y)),
   GetX::static:= ((p::Point)-> p:-x),
   GetY::static:= ((p::Point)-> p:-y),
   Show:= proc(p::Point)
      printf("Point X,Y -> [%f,%f]", p:-x, p:-y);
      NULL
   end proc
;
end module:

Usage:

p1:=Point(1.2,1.4);
p2:=Point(1.0,2.0);
                         p1:= [1.2, 1.4]
                         p2:= [1.0, 2.0]
p2:= p1+p2;
                         p2:= [2.2, 3.4]
Show(p2);
Point X,Y -> [2.200000,3.400000]

Note that this doesn't require the use of option package, option overload, or with; and the use of Show doesn't require a module prefix. Maple uses the fact that the argument to Show is an object to know where to look first for procedure Show. More subtly, Maple uses the fact that the arguments to `+` are objects to know where to look first for the overloaded code for `+`.

Unfortunately, there's a lot of new syntax involved with these objects, as evidenced above. There's a lot of help files to read about this. Start with ?object, ?object,operators, and ?ProgrammingGuide,Chapter09.

Can someone tell me why the vacuous ModuleType in my code above seems to be required even though I don't use any structured types?

We might as well make an approximation of the infinite product, if Maple is willing to do so, rather than truncating at 1001 terms. I have taken the exponential of the logarithm of Mariusz's formula from Wikipedia, because Maple is more willing to evalf infinite Sums than infinite Products.

qgamma:= (z,q)-> evalf(exp((1-z)*ln(1-q) + Sum(ln((1-q^(n+1))/(1-q^(n+z))), n= 0..infinity))):

qgamma(0.8, 0.9);
     1.15699155036365

To convert the bit string to 65, use

convert("01000001", decimal, binary);

To convert it to the character "A", first convert it to 65, then use StringTools:-Char(...).

Also consider using numtheory:-factorset for this purpose. It returns a set of just the prime bases, no exponents. There's nothing different about its underlying algorithm: It simply extracts the bases from the output of ifactors.

Here's another way. It's no better than the other ways presented. I just present it because if you do a lot of work with permutations, you should learn about the conversion to disjoint cycle form, which makes a lot of work with permutations easier. It makes computing the parity of a permutation trivial: It's odd iff there's an odd number of even-length cycles.

parity:= (p::list(posint))-> mul((-1)^~(nops~(convert(p, disjcyc)) -~ 1)):

parity([1, 3, 2, 4, 5]);
     -1

op([1,1,1], ifactor(12));

Remove the restart command from the startup code. The restart command should only be used in the main body of the worksheet.

Here's a new version of fprintf that does what Acer was intending:

My_fprintf:= proc(fp::{nonnegint, name}, form::string:= "%a\n")
   fprintf(fp, form, subsindets([_rest], float, evalf[interface(displayprecision)])[])
end proc:
Example:
Digits:= 25:
interface(displayprecision= 5):
My_fprintf(terminal, evalf(1/3+x/6)):
.33333+.16667*x

Also note that interface(displayprecision) is incorrectly named: It controls the number of digits after the decimal point that are displayed. That's not exactly the same thing as precision. For example:

x:= 0.00000123;
                           x:= 0.00000

That's not five digits precision!

Here's a procedure that's significantly faster than Joe's RtableToInverseMap in the case that there are many repeated entries:

InvertRtable:= (A::rtable)-> Threads:-Map(op@((`[]`@lhs)~), ListTools:-Classify(rhs, rtable_elems(A))):

It produces output identical to Joe's except that there are no zeros.

Time comparison:

A:= LinearAlgebra:-RandomMatrix(400$2, generator= rand(0..9)):
CodeTools:-Usage(InvertRtable(A)):
memory used=0.93GiB, alloc change=385.10MiB, cpu time=14.23s, real time=3.11s, gc time=546.88ms
CodeTools:-Usage(RtableToInverseMap(A)):
memory used=9.56GiB, alloc change=128.00KiB, cpu time=38.66s, real time=26.34s, gc time=22.00s