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:
This invention was made with Government support under contract F29601-97-C-0001 awarded by the United States Air Force. The government has certain rights in this invention. 
    
    
     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 )=2 xH   n ( x )−2 nH   n−1 ( x ).
 
     All higher-order polynomials can, therefore, be generated from the zero-order Hermite function, H 0 (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   −x     2     {tilde over (H)}   n (√{square root over (2)} x ) and  {tilde over (H)}   n ( x )=H n ( x )/√{square root over (2 n   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 n   x   2n )} =H   n ( x )/[(2 x ) n π 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 /2 x   2 ) Ĥ   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 2 ], The “smooth” Hermite function is defined as:
 
   H     n ( x )= Ĥ   n ( x ) e   n(n−1)/4x     2   .
 
     The recursion formula for the smooth Hermite becomes:
 
   H     n+1 ( x )=   H     n ( x ) e   n/2x     2   −( n /2 x   2 )   H     n ( x ) e   (2n−1)/2x     2   .
 
     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)/ax     2    and    H     n+1 ( x )=   H     n ( x ) e   2n/ax     2   −( n /2 x   2 )   H     n ( x ) e   (4n−2)/ax     2   .
 
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: 
                       G   n     ⁡     (   x   )       =       ⅇ     -     x   2         ⁢         H   n     ⁡     (       2     ⁢   x     )       /         2   n     ⁢     n   !     ⁢     π                         =       ⅇ     -     x   2         ⁢         H   ^     n     ⁡     (       2     ⁢   x     )       ⁢         (     2   ⁢   x     )     n     /       n   !                       =       [       ⅇ     -     x   2         ⁢           ⅇ       -     n   ⁡     (     n   -   1     )         /     (     2   ⁢     ax   2       )         ⁡     (     2   ⁢   x     )       n     /       n   !           ]     ⁢         H   _     n     ⁡     (       2     ⁢   x     )                     =         F   n     ⁡     (   x   )       ⁢         H   _     n     ⁡     (       2     ⁢   x     )                     
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 n e −n  and transform F n (x) as follows:
 
     
       
         
           
             
               
                 
                   
                     
                       F 
                       n 
                     
                     ⁡ 
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     [ 
                     
                       
                         ⅇ 
                         
                           - 
                           
                             x 
                             2 
                           
                         
                       
                       ⁢ 
                       
                         
                           
                             
                               ⅇ 
                               
                                 
                                   - 
                                   
                                     n 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                                 / 
                                 
                                   ( 
                                   
                                     2 
                                     ⁢ 
                                     
                                       ax 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 2 
                                 ⁢ 
                                 x 
                               
                               ) 
                             
                           
                           n 
                         
                         / 
                         
                           
                             n 
                             ! 
                           
                         
                       
                     
                     ] 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         
                           
                             n 
                             n 
                           
                           
                             
                               n 
                               ! 
                             
                             ⁢ 
                             
                               ⅇ 
                               n 
                             
                           
                         
                       
                       [ 
                       
                         
                           
                             ⅇ 
                             n 
                           
                         
                         ⁢ 
                         2 
                         ⁢ 
                         x 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ⅇ 
                           
                             
                               - 
                               
                                 
                                   x 
                                   2 
                                 
                                 n 
                               
                             
                             - 
                             
                               
                                 n 
                                 - 
                                 1 
                               
                               
                                 2 
                                 ⁢ 
                                 
                                   ax 
                                   2 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     n 
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         
                           C 
                           n 
                         
                         [ 
                         
                           ⅇ 
                           
                             ( 
                             
                               
                                 1 
                                 2 
                               
                               + 
                               
                                 ln 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 2 
                               
                               + 
                               
                                 
                                   1 
                                   2 
                                 
                                 ⁢ 
                                 ln 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     x 
                                     2 
                                   
                                   n 
                                 
                               
                               - 
                               
                                 
                                   x 
                                   2 
                                 
                                 n 
                               
                               - 
                               
                                 
                                   n 
                                   - 
                                   1 
                                 
                                 
                                   2 
                                   ⁢ 
                                   
                                     ax 
                                     2 
                                   
                                 
                               
                             
                             ) 
                           
                         
                         ] 
                       
                       n 
                     
                     = 
                     
                       
                         
                           C 
                           n 
                         
                         ⁡ 
                         
                           [ 
                           
                             ⅇ 
                             
                               
                                 f 
                                 n 
                               
                               ⁡ 
                               
                                 ( 
                                 x 
                                 ) 
                               
                             
                           
                           ] 
                         
                       
                       n 
                     
                   
                 
               
             
           
         
       
     
     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     =           1   ⅇ     ⁢       (     n     n   -   1       )       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.