I am trying to find 6 unknowns A, B, C, L, E, and F and have managed to write down a system of 6 equations involving these unknowns.  However, the equations are long and which I try to put the system together and solve with solve(sys, {A, B, C, E, F, L}) it says `[Length of output exceeds limit of 1000000]`.  Although the equations are long, I feel like something must be going wrong as the output cannot be that long.  The equations are:

C = (((h/(4*Pi*K)*H*e^(-k*h)*I/k - k*h^2/2 + H*A*e^(-k*h)*I/(K*k^2) - B*h - sqrt(Pi/2)*h/(2*Pi)*H*e^(-k*h)*I + sqrt(Pi/2)*K*k*h - sqrt(Pi/2)*H*A*e^(-k*h)*I/k + sqrt(Pi/2)*B*K - sqrt(Pi/2)*K*H*k*h^2*I/2) + sqrt(Pi/2)*H*A*e^(-k*h)*I/k) - sqrt(Pi/2)*H*F*h*K*I - sqrt(Pi/2)*H*A*e^(-k*h)*I/k + sqrt(Pi/2)*K*H*k*h^2/2*I) - sqrt(Pi/2)*H*F*h*K*I,

E = (((h/(4*Pi*K)*J*e^(-k*h)*I/k - k*h^2/2 + J*A*e^(-k*h)*I/(K*k^2) - L*h - sqrt(Pi/2)*h/(2*Pi)*J*e^(-k*h)*I + sqrt(Pi/2)*K*k*h - sqrt(Pi/2)*J*A*e^(-k*h)*I/k + sqrt(Pi/2)*L*K - sqrt(Pi/2)*K*J*k*h^2*I/2) + sqrt(Pi/2)*J*A*e^(-k*h)*I/k) - sqrt(Pi/2)*J*F*h*K*I - sqrt(Pi/2)*J*A*e^(-k*h)*I/k + sqrt(Pi/2)*K*J*k*h^2/2*I) - sqrt(Pi/2)*J*F*h*K*I

0 = -H*(k*z^2/2 - H*A*e^(-k*z)*I/(K*k^2) + B*z + C)*I - J*(k*z^2/2 - J*A*e^(-k*z)*I/(K*k^2) + L*z + E)*I + k*z + A*e^(-k*z)/K + F

0 = ((-H*A*e^(-k*z)*I - H*I*(-2*K*(-H*k*z^2*I/2 - H^2*A*e^(-k*z)/(K*k^2) - H*B*z*I - H*C*I)) - J*I*(-2*K*1/2*(((-J*k*z^2*I/2 - J*H*A*e^(-k*z)/(K*k^2) - J*B*z*I - J*C*I - H*k*z^2*I/2) - J*H*A*e^(-k*z)/(K*k^2)) - H*L*z*I - i*H*E)) - K*k) + H*A*e^(-k*z)*I) + K*H*z*k*I + H*A*e^(-k*z)*I + K*H*F*I

0 = ((-J*A*e^(-k*z)*I - H*(((K*J*k*z^2*I/2 + J*H*A*e^(-k*z)/k^2 + K*J*B*z*I + k*h*K*z^2*I/2) + J*H*A*e^(-k*z)/k^2) + K*H*L*z*I + K*H*E*I)*I - J*I*(-2*K*(-J*k*z^2*I/2 - J^2*A*e^(-k*z)/(K*k^2) - J*L*z*I - J*E*I)) - K*k) + J*A*e^(-k*z)*I) + K*J*z*k*I + J*A*e^(-k*z)*I + K*J*F*I

0 = (-k*A*e^(-k*z) - H*I*(-2*K*1/2*(((k*z + H*A*e^(-k*z)*I/(K*k) + B - H*k*z^2*I/2) + H*A*e^(-k*z)*I/(K*k)) - H*F*z*I - H*G*I)) - J*I*(-2*K*1/2*(((k*z + J*A*e^(-k*z)*I/(K*k) + L - J*k*z^2*I/2) + J*A*e^(-k*z)*I/(K*k)) - J*F*z*I - J*G*I)) - 2*K*k) + 2*k*A*e^(-k*z)

where h takes a constant value, H and J are constants, k is the square root of H^2 + J^2, I is the imaginary unit, and z also takes some value as a parameter.

I am reading a paper which has some useful two-dimensional Fourier transforms in the appendix: for example,

Fourier transform of 1/r = (1/k)*e^(-kz),

where r = sqrt(x^2 + y^2 + z^2) and k =  sqrt(k_1^2 + k_2^2).

My guess is that the author has computed these by taking contour integrals in the upper half-plane and I would like to compute some of these myself but I have many of them to compute and was wondering if it could be done with Maple instead.

For example, could I use Maple to verify that the above 2D Fourier transform is correct and that the inverse 2D Fourier transform takes you back to the original (or almost takes you back).  After that I would then like to feed in the functions which I have to get Fourer and inverse Fourier transforms.

I have the following ODE which I would like to solve with Maple rather than solving by hand (having solved this type of equation by hand many times now):

diff(f(x,y,z),z$2) = A - B*e^(-A*z)

where A and B are constants and I have indicated the second derivative of a function of x,y and z with respect to z.  

I have a differential equation involving several functions of the following form:

diff(h,z) = iAf + iBg,

where h, f and g are functions of the Cartesian coordinates x, y and R and the third coordinate corresponds to z = R for some fixed constant value R.  The derivative is then with respect to the coordinate z and A and B are constants, with i the usual imaginary unit.  Is there some way this equation could be solved explicitly with Maple?

I am working on a physics problem where I will need to generate random unitaries of size N x N.   

As I understand it this would require me to sample uniformly from U(N), where 'uniform' is in the sense of the Haar measure.  I believe this construction in Mathematica is called 'circular unitary ensemble' and was wondering if there was a similar routine in Maple or some simple code that would allow me to generate random unitaries of particular size.