Method and means for generating high-order hermite functions for simulation of electromagnetic wave devices

Abstract

A technique for generating very-high-order Hermite functions needed for accurately simulating operation of various devices and structures involving propagation of electromagnetic waves. By using modified recursion formulas, the technique generates asymptotic Hermite functions, smooth Hermite functions or optimized smooth Hermite functions, allowing for very high orders of the functions to be generated without the intermediate function values becoming so large as to exceed the capacity of conventional computers. The disclosed method for generating smooth Hermite functions provides for generation of well-behaved functions of order 30,000 or higher.

Description

BACKGROUND OF THE INVENTION

This invention relates generally to techniques for generating very high-order Hermite functions and, more particularly, to the generation of high-order Hermite-Gaussian functions for use in simulating operation of various devices in which electromagnetic waves are propagated in a cavity or in free space. Hermite functions, usually indicated by H_n(x), have been used extensively in the construction of antenna patterns, in the representation of laser beams and in the simulation of electromagnetic wave behavior in stable laser cavities. Mathematical representation of electromagnetic (EM) waves is difficult because EM waves typically behave in a complex manner involving many modes of propagation. It is well known that Hermite functions can be used in the simulation of EM wave behavior in various environments, and that the accuracy of the mathematical representation is dependent on the extent to which higher-order Hermite functions can be generated. In particular, the accuracy of the mathematical representation is increased by the use of higher-order Hermite functions.

The Hermite function is a polynomial that can be generated for order n+1 from the same functions generated for order n and order n−1, using a classic recursion formula:H_n+1(x)=2xH_n(x)−2nH_n−1(x).

All higher-order polynomials can, therefore, be generated from the zero-order Hermite function, H₀(x)=1. For almost any value of x, the resulting values of the Hermite functions increase very rapidly with n, and increase especially rapidly when x is large. To reduce the functions to a manageable magnitude, the Hermite functions are usually normalized according to the Hermite-Gaussian function, which is defined as:G_n(x)=e^−x2{tilde over (H)}_n(√{square root over (2)}x) and {tilde over (H)}_n(x)=H_n(x)/√{square root over (2ⁿn!√{square root over (π)})}.where G_n(x) is the order-n Hermite-Gaussian function of x and {tilde over (H)}_n(x) is the normalized order-n Hermite function of x.

The Hermite-Gaussian function, G_n(x), has a finite and oscillating dependence on x up to x˜(n+1)^1/2. FIGS. 1A-1D depict computed Hermite-Gaussian functions for n=10, 50, 200 and 250, respectively, each plotting the function value for increasing positive and negative values of x (along the horizontal axis). These graphs were generated using a commercially available mathematical software package (MATHEMATICA®). In general, each graph shows the finite and oscillating dependence on x up to x˜(n+1)^1/2. For example, the Hermite-Gaussian function for n=10 oscillates regularly up to x˜3, as shown in FIG. 1A, and for n=50 up to x˜7, as shown in FIG. 1B. For the highest order shown (n=250, in FIG. 1D), the Hermite-Gaussian function generated begins to show a rapid increase in magnitude and irregular variations before reaching the x value of 251^1/2 (˜16). In other words, the generating process completely breaks down in this case. The graph of FIG. 1D is, in fact, an illustration of a critical hardware limitation in the generation of high-order Hermite-Gaussian functions. Most computers currently manufactured for scientific calculations employ a 32-bit or 64-bit word length for storage and computation. The largest number that can be stored in the 64-bit format is determined-by the format used for the numbers stored. In a widely used standard for floating-point numbers, promulgated by the IEEE (Institute for Electrical and Electronics Engineers), the 64-bit word includes one sign bit, an 11-bit exponent and a 52-bit fraction. In this format the largest number that can be stored in a 64-bit word is approximately 2^∀1023˜10^∀308.

One possible solution to this hardware limitation is to employ the multiprecision computation system proposed by David H. Bailey of NASA (National Aeronautics and Space Administration). For details, see a paper by David H. Bailey entitled “Fortran-90 Based Multiprecision System,” RNR Technical Report RNR-94-013, Jun. 6, 1994. Basically, the Bailey system allows the number of precision digits to be increased into the millions. The disadvantages of this software solution are that it requires the use of Fortran-90 and an external library, and, when implemented, it runs much slower than the conventional Hermite function generator.

Alternatively an improvement can be realized with the use of the recursion formula for normalized Hermite functions. This recursion formula defines the normalized Hermite function of order n+1 as:{tilde over (H)}_n+1(x)=[√{square root over (2)}x{tilde over (H)}_n(x)−√{square root over (n)}{tilde over (H)}_n−1(x)]/√{square root over (n+)}1.This formula is able to push the recursive generation of Hermite functions to a higher order than if the classic recursion formula is used, but not much higher, and certainly not high enough to meet the needs of many applications involving simulation and analysis of electromagnetic wave phenomena.

It will be appreciated from the foregoing that there is still a need for a new approach for generation of Hermite functions of very high order, such as n greater than 10.000. Improvements in the generation of Hermite functions prior to this invention have not been able to reach anywhere near this goal because higher order Hermite functions become so large as to exceed the computational limits of conventional computers. Therefore, there is a need for a modified Hermite function generator that results in functions that are “well behaved” even at orders n much greater than 10,000. The present invention satisfies this need.

SUMMARY OF THE INVENTION

The present invention resides in a technique for generating Hermite functions of a new form, such that the functions generated at very high orders are within manageable magnitudes that can be represented in conventional computers. One form of the invention is a method for simulating operation of a device employing an electromagnetic wave phenomenon. Briefly, and in general terms, the method comprises the steps of inputting physical parameters of the device; generating a series of order-zero through order-n Hermite functions that have manageable values at very high values of n; simulating operation of the device to a high degree of accuracy by making use of the generated high-order Hermite functions; and outputting performance characteristics of the device. The generating step comprises applying a recursion formula to generate successively higher order Hermite functions. The recursion formula generates manageable values up to an order n of at least several thousand.

In accordance with other embodiments of the invention, variations of the recursion formula provide for generation of smooth Hermite functions and optimized smooth Hermite functions, allowing generation of such functions up an order of 30,000 and beyond.

In terms of apparatus, the invention may be also be defined as a programmable computer for simulating operation of a device employing an electromagnetic wave phenomenon, the programmable computer comprising means for inputting physical parameters of the device; means for generating a series of order zero through order n Hermite functions that have manageable values at very high values of n; means for simulating operation of the device to a high degree of accuracy by making use of the generated high-order Hermite functions; and means for outputting performance characteristics of the device. The means for generating comprises means for applying a recursion formula to generate successively higher order Hermite functions, and the recursion formula generates manageable values up to an order n of at least several thousand, or, if the smooth recursion formula is used, up to at least 30,000.

Generation of Hermite functions at these very high orders has long been needed in various fields relating to simulation and analysis of electromagnetic wave propagation, either within devices or structures, or in free space. Therefore, it will be appreciated that the present invention represents a significant advance in the study and design of devices utilizing electromagnetic waves. In particular, the generation of Hermite functions of very high order leads to improved accuracy in modeling the behavior of electromagnetic wave propagation in its various modes. Other aspects and advantages of the invention will become apparent from the following more detailed description of the invention, taken in conjunction with the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIGS. 1A-1D are graphs depicting the variation of a Hermite-Gaussian function G_n(x) as x is varies positively and negatively, for order n=10, 50, 200 and 250, respectively.

FIG. 2 is a simplified block diagram depicting the function of a simulation computer or model including a classic Hermite-Gaussian function generator.

FIG. 3 is a simplified block diagram similar to FIG. 2, but including the advanced Hermite-Gaussian function generator of the present invention.

FIG. 4 is a graph comparing the performance of the classic Hermite function generator with the normalized Hermite function generator and an asymptotic Hermite function generator of the present invention, over a range of order n up to 500.

FIG. 5 is a graph comparing the performance of the asymptotic Hermite function with a smooth Hermite function generator in accordance with the invention, over a range of n up to 30,000.

FIG. 6 is a graph showing the n-dependent variation of a “constant” (C_n) used to transform a smooth Hermite function to an equivalent Hermite-Gaussian function in accordance with one aspect of the invention.

DETAILED DESCRIPTION OF THE INVENTION

As shown in the drawings for purposes of illustration, the present invention pertains to an improved technique for generating Hermite or Hermite-Gaussian functions for use in a simulation or modeling computer. As shown in FIG. 2, a simulation computer or model 10 has the general function of manipulating a plurality of input signals 12 representative of physical parameters of a device or structure to be simulated, and generating a plurality of output signals 14 representative of the performance characteristics of the device or structure. For many simulation or modeling applications in which the device or structure to be simulated involves the propagation of electromagnetic waves, the simulation computer 10 necessarily includes a Hermite-Gaussian function generator 16. Prior to the present invention, the function generator 16 was unable to generate Hermite or Hermite-Gaussian functions that were “well behaved” at higher orders. That is to say, the generated function became impractically large in value at orders n far below those that were ideally desired for the accurate simulation or analysis of electromagnetic wave phenomena. Although better performance, in the form of higher orders n, could be achieved by using a normalized version of the Hermite function recursion formula, no-one prior to the present invention has been able to generate well behaved Hermite functions of very high order, such as n=10,000 or more.

In accordance with the present invention, and as illustrated generally in FIG. 3, the simulation computer 10 includes an advanced Hermite-Gaussian function generator 20, capable of generating a function whose value remains manageably sized over a wide range of order n up to and into the tens of thousands. The following description explains in mathematical terms how the classic Hermite function generator is modified in accordance with the invention to achieve this performance goal.

A first level of performance improvement can be obtained by using an asymptotic Hermite function. First, it is noted that the highest order term in each Hermite function behaves as H_n(x)˜(2x)″. An asymptotic form of the function can be defined as:Ĥ_n(x)={tilde over (H)}_n(x)√{square root over (n!)}/√{square root over (2ⁿx²ⁿ)}=H_n(x)/[(2x)ⁿπ^1/4],where Ĥ_n(x) is the order-n asymptotic Hermite function of x and {tilde over (H)}_n(x) is the order-n normalized Hermite function of x.

The asymptotic Hermite functions then follow a simpler recursion formula:Ĥ_n+1(x)=Ĥ_n(x)−(n/2x²)Ĥ_n−1(x).

This results in a better-behaved function for higher orders n. FIG. 4 compares the function values of the classic Hermite function (curve 30), the normalized Hermite function (curve 32) and the asymptotic Hermite function (curve 34) for x=180˜32,000^1/2. The latter curve is shown as essentially flat over a range of n up to 500. The asymptotic formula takes the Hermite function generation to an order n beyond ten thousands before the function value becomes too large to be manageable. This compares favorably with the classic Hermite function, the value of which exceeds conventional computational limits at about n=100, and the normalized Hermite function, which similarly fails at about n=200. Although the asymptotic form of the Hermite function pushes the useful range of the order n into the thousands, a much higher useful range would be desirable for many applications.

In accordance with an important aspect of the invention, a “smooth” Hermite function can be generated to an order n in the tens of thousands. It is noted from the recursion formula for the asymptotic Hermite function that for large values of x, the asymptotic Hermite function behaves like exp[−n(n−1)/4x²], The “smooth” Hermite function is defined as:H_n(x)=Ĥ_n(x)e^n(n−1)/4x2.

The recursion formula for the smooth Hermite becomes:H_n+1(x)=H_n(x)e^n/2x2−(n/2x²)H_n(x)e^(2n−1)/2x2.

Using this formula, one can easily extend the validity of recursive generation. To optimize the process, an adjustable parameter, a, is introduced into the exponential expression, and the following relationships apply:H_n(x)=Ĥ_n(x)e^n(n−1)/ax2 and H_n+1(x)=H_n(x)e^2n/ax2−(n/2x²)H_n(x)e^(4n−2)/ax2.Using a value of a=2.8 gives the best result, in that the function values for very high orders are well within the level of machine accuracy (and do not exceed 10^∀150). FIG. 5 compares the values for the smooth Hermite function with corresponding values for the asymptotic Hermite function, both at x=180. The asymptotic Hermite function fails (becomes unstably large) at order n˜13,000, but the smooth Hermite function is well behaved at values of n beyond 32,000. Moreover, none of the function values over this range exceed the machine limit.

After the generation of a smooth Hermite function, the extra factor can be easily added back to obtain the normal values of Hermite-Gaussian functions in a relatively simple manner, as will now be explained in more detail.

The Hermite-Gaussian function is related to the smooth Hermite function as:

$\begin{array}{c}{G}_n\left(x\right)=e^{-x^2}{H}_n\left(\sqrt{2}x\right)/\sqrt{2^{n}n!\sqrt{\pi }}\\ =e^{-x^2}{\hat{H}}_n\left(\sqrt{2}x\right){\left(2x\right)}^n/\sqrt{n!}\\ =\left[e^{-x^2}{e^{-n\left(n-1\right)/\left(2{\mathrm{ax}}^2\right)}\left(2x\right)}^n/\sqrt{n!}\right]{\stackrel{\_}{H}}_n\left(\sqrt{2}x\right)\\ =F_n\left(x\right){\stackrel{\_}{H}}_n\left(\sqrt{2}x\right)\end{array}$ where the explicit factor function F_n(x) is expected to be well behaved for all values of n and x, at least within a range of interest. To evaluate this factor function, one can consider the approximation n!≈√{square root over (2πn)}nⁿe⁻ⁿ and transform F_n(x) as follows:

$\begin{array}{c}{F}_n\left(x\right)=\left[e^{-x^2}{e^{-n\left(n-1\right)/\left(2{\mathrm{ax}}^2\right)}\left(2x\right)}^n/\sqrt{n!}\right]\\ ={\sqrt{\frac{n^n}{n!e^n}}\left[\sqrt{\frac{e}{n}}2x{e}^{-\frac{x^2}{n}-\frac{n-1}{2{\mathrm{ax}}^2}}\right]}^n\\ ={C_n\left[e^{\left(\frac{1}{2}+\ln 2+\frac{1}{2}\ln \frac{x^2}{n}-\frac{x^2}{n}-\frac{n-1}{2{\mathrm{ax}}^2}\right)}\right]}^n={C_n\left[e^{f_n\left(x\right)}\right]}^n\end{array}$

The function ƒ_n(x) is small enough for x˜n^1/2 that the exponential can be evaluated within the machine limit of 10^∀308. The n-dependent constant C_n can be obtained from the following recurrence formula:

$C_n=\sqrt{\frac{1}{e}{\left(\frac{n}{n-1}\right)}^{n-1}}{C}_{n-1}$ As n proceeds to a very high value, C_n varies from a value of 1 (at n=0) to a value of ˜0.05 (for n=15,000 to more than 30,000). FIG. 6 shows this variation of C_n over a wide range of order n. From the foregoing relationships, a generated smooth Hermite function can be converted into a corresponding Hermite-Gaussian function.

It will be appreciated from the foregoing that the present invention represents a significant advance in the field of computer simulation or modeling of electromagnetic waves and related devices in which or from which such waves are propagated. In particular, the invention provides a technique for generating Hermite-Gaussian functions to a very high order while maintaining the value of such functions well below the practical machine limit for holding large numerical quantities. These very high-order Hermite-Gaussian functions allow more accurate simulation or modeling of electromagnetic wave phenomena, in such contexts as antennas, laser cavities and free-space communication. It will also be appreciated that, although specific embodiments of the invention have been described in detail by way of example, various modifications may be made without departing from the spirit and scope of the invention. Accordingly, the invention should not be limited except as by the appended claims.

Claims

1. A method for simulating operation of a device employing an electromagnetic wave phenomenon, the method comprising the steps of: inputting physical parameters of the device;generating a series of order zero through order n Hermite functions that have manageable values at very high values of n, wherein the generating step comprises applying a recursion formula to generate successively higher order Hermite functions, and wherein the recursion formula generates manageable values up to an order n of at least several thousands;simulating operation of the device by making use of the generated higher order Hermite functions; andoutputting performance characteristics of the device.

2. A method as defined in claim 1, wherein: the step of generating a series of Hermite functions comprises generating asymptotic Hermite functions in accordance with a recursion formula expressed as Ĥn+1(x)=Ĥn(x)−(n/2x2)Ĥn−1(x),

3. A method as defined in claim 1, wherein: the step of generating a series of Hermite functions comprises generating smooth Hermite functions in accordance with a recursion formula expressed as Hn+1(x)=Hn(x)en/2x2−(n/2x2)Hn(x)e(2n−1)/2x2,

4. A method as defined in claim 1, wherein: the step of generating a series of Hermite functions comprises generating optimized smooth Hermite functions in accordance with a recursion formula expressed as: Hn+1(x)=Hn(x)e2n/ax2−(n/2x2)Hn(x)e(4n−2)/ax2,

5. A method as defined in claim 4, wherein a is approximately 2.8.

6. A method as defined in claim 4, and further comprising the step of: transforming each optimized smooth Hermite function into an equivalent Hermite-Gaussian function.

7. A method as defined in claim 6, wherein the transforming step is performed in accordance with the relation Gn(x)=Fn(x)Hn(√{square root over (2)}x),

8. A programmable computer for simulating operation of a device employing an electromagnetic wave phenomenon, the programmable computer including a Hermite-Gaussian function generator, the programmable computer comprising: means for inputting physical parameters of the device;means for generating a series of order zero through order n Hermite functions that have manageable values at very high values of n, wherein the means for generating comprises means for applying a recursion formula to generate successively higher order Hermite functions, and wherein the recursion formula generates manageable values up to an order n of at least several thousands;means for simulating operation of the device by making use of the generated higher order Hermite functions; andmeans for outputting performance characteristics of the device.

9. A programmable computer as defined in claim 8, wherein: the means for generating a series of Hermite functions comprises means for generating asymptotic Hermite functions in accordance with a recursion formula expressed as Ĥn+1(x)=Ĥn(x)−(n/2x2)Ĥn−1(x),

10. A programmable computer as defined in claim 8, wherein: the means for generating a series of Hermite functions comprises means for generating smooth Hermite functions in accordance with a recursion formula expressed as Hn+1(x)=Hn(x)en/2x2−(n/2x2)Hn(x)e(2n−1)/2x2,

11. A programmable computer as defined in claim 8, wherein: the means for generating a series of Hermite functions comprises means for optimized smooth Hermite functions in accordance with a recursion formula expressed as: Hn+1(x)=Hn(x)e2n/ax2−(n/2x2)Hn(x)e(4n−2)/ax2,

12. A programmable computer as defined in claim 11, wherein a is approximately 2.8.

13. A programmable computer as defined in claim 11, and further comprising: means for transforming each optimized smooth Hermite function into an equivalent Hermite-Gaussian function.

14. A programmable computer as defined in claim 13, wherein the means for transforming functions in accordance with the relation Gn(x)=Fn(x)Hn(√{square root over (2)}x),

15. A computer storage medium containing a software module operable to cause a computer to perform steps for simulating operation of a device employing an electromagnetic wave phenomenon, the computer performing the steps of: receiving physical parameters of the device;generating a series of order zero through order n Hermite functions that have manageable values at very high values of n, wherein the generating step comprises applying a recursion formula to generate successively higher order Hermite functions, and wherein the recursion formula generates manageable values up to an order n of at least several thousands; andoutputting performance characteristics of the device based on the generated higher order Hermite functions.

16. A computer storage medium as defined in claim 15, wherein: the step of generating a series of Hermite functions comprises generating asymptotic Hermite functions in accordance with a recursion formula expressed as Ĥn+1(x)=Ĥn(x)−(n/2x2)Ĥn−1(x),

17. A computer storage medium as defined in claim 15, wherein: the step of generating a series of Hermite functions comprises generating smooth Hermite functions in accordance with a recursion formula expressed as Hn+1(x)=Hn(x)en/2x2−(n/2x2)Hn(x)e(2n−1)/2x2,

18. A computer storage medium as defined in claim 15, wherein: the step of generating a series of Hermite functions comprises generating optimized smooth Hermite functions in accordance with a recursion formula expressed as: Hn+1(x)=Hn(x)e2n/ax2−(n/2x2)Hn(x)e(4n−2)/ax2,

19. A computer storage medium as defined in claim 18, wherein a is approximately 2.8.

20. A computer storage medium as defined in claim 18, and the steps further comprise: transforming each optimized smooth Hermite function into an equivalent Hermite-Gaussian function.

21. A computer storage medium as defined in claim 20, wherein the transforming step is performed in accordance with the relation Gn(x)=Fn(x)Hn(√{square root over (2)}x),