Abstract:
A method of approximating the behavior of an integrated circuit includes applying a set of test patterns to a system for testing or simulating an integrated circuit, applying the set of test patterns to a neural network, comparing the outputs of the system for testing or simulating the integrated circuit and the outputs of the neural network, and adapting parameters of the neural network to approximate the behavior of the integrated circuit on the basis of the comparison. The dynamic behavior of the integrated circuit device can be learned from a set of random test patterns using a neural network. After the learning process has been completed, the automatic test equipment is able to perform a test pattern classification. The automatic test equipment may thus select test patterns for a subsequent simulation or testing of the integrated circuit. The selected patterns can be further optimized using a genetic algorithm.

Description:
BACKGROUND OF THE INVENTION  
         [0001]    1. Field of the Invention  
           [0002]    To achieve high performance and high integration density, the dimensions of integrated circuit components are scaled down more and more. In particular, transistor dimensions are scaled down while lower power dissipation is achieved by scaling down the supply voltage. However, due to high packing density of transistors, the power supply current is increasing, and hence, large current swings within a short period of time can cause considerable noise. As a consequence, one difficulty circuit designers face is the power delivery of very high performance circuits due to the severe switching noise.  
           [0003]    In order to verify the function of a newly designed integrated circuit, the circuit is first simulated and then tested. During simulation, multiple input signals are applied to the inputs of the circuit, and the output signals of the circuit calculated. The input signals are referred to as test patterns. If the output signals do not sufficiently approximate preset target signals, the circuit is redesigned and re-simulated.  
           [0004]    Subsequently, when simulation is completed, a chip containing the integrated circuit is manufactured and tested using ATE (Automatic Test Equipment). The ATE also applies a test pattern to the circuit. The test pattern for the ATE has to be input manually by a user. Generally, the same test pattern that has been used for simulation is also used for testing. If the output signals generated by the circuit in response to the test pattern of the ATE deviate from preset target signals, the circuit is redesigned, re-simulated and retested.  
           [0005]    As the complexity of integrated circuits increases, integration density and functionality increases dramatically. The simultaneous switching of a large number of transistors induces a large current spike. The switching noise on the power distribution network must be suppressed to a tolerable level to ensure the reliability of the circuit. In order to efficiently combat the switching noise, estimation of the worst case switching noise is required.  
           [0006]    On way of determining the worst case switching noise is to simulate all combinations of input patterns to determine which combination will induce the maximum switching noise. However, the complexity of the solution space is exponentially proportional to the number of primary inputs of the system. Accordingly, it would require an enormous time to process the entire solution space for even a moderately complex system.  
           [0007]    As a consequence, it is almost impossible to determine all test patterns that cause worst case switching noise by simulation or testing. Accordingly, a small set of test patterns that cause at least some worst case scenarios can be selected. However, this way, the simulation or testing of the integrated circuit may not be satisfactory.  
           [0008]    The designer thus has to accept either enormous time requirements for simulation and testing, or potentially insufficient simulation or testing efficiency. This is clearly undesirable.  
           [0009]    To this end, some approaches have been proposed to deal with these problems. In “Estimation of Switching Noise on Power Supply Lines in Deep Sub-micron CMOS circuits”, Shiyou Zhao and Kaushik Roy, 13 th  International Conference on VLSI Design, IEEE January 2000, there is proposed a probabalistic approach to determine the lower bound of the worst case switching noise on power supply lines. The algorithm described therein traces the worst case input patterns which induces the steepest maximum switching current spike and therefore the maximum switching noise. This is based on the observation that the maximum switching noise is directly related to the steepest maximum switching current spike.  
           [0010]    In this approach, the design of an integrated circuit is simulated by applying randomly generated input signal vectors to the inputs of the circuit. For each input vector pair, the simulated peak switching current is determined. The worst case input vector pairs feed, as initial population, a genetic algorithm. The genetic algorithm is designed to single out the near optimal input pattern(s) that induce the steepest maximum switching current spike and, therefore, the worst case switching noise. The worst case input patterns are then used in HSPICE (simulation program with integrated circuit emphasis) simulation of the circuits to extract the exact current waveform.  
           [0011]    One problem associated with this approach is the difficulty of generating suitable random test patterns. The larger the number of random test patterns, the higher the likelihood of generating a test pattern which approximates the worst case sufficiently. However, since the simulation of each test pattern is time consuming, the simulation of a large number of test patterns is not practical.  
           [0012]    In particular, if a genetic algorithm is used, it is too time consuming to simulate every single random pattern out of every new pattern population before the algorithm is able to determine which of the patterns of the population is to be selected for further optimization. Therefore, this method becomes saturated by the number of trial random patterns in each pattern population. It is suitable for small circuits. However, it could take up to years to perform a full chip simulation of a large circuit using even the fastest simulation applications.  
         SUMMARY OF THE INVENTION  
         [0013]    It is accordingly an object of the invention to provide a method of approximating a behavior of an integrated circuit, a method of selecting test patterns, a method of simulating an integrated circuit, a method of testing an integrated circuit, a method of providing a test pattern for a simulation or a test of a layout of an integrated circuit, a data processing configuration, and a computer-readable medium having computer-executable instructions for performing a method approximating a behavior of an integrated circuit which overcome the above-mentioned disadvantages of the heretofore-known methods and devices of this general type.  
           [0014]    With the foregoing and other objects in view there is provided, in accordance with the invention, a method of approximating the behavior of an integrated circuit including the steps of:  
           [0015]    (a) applying a set of test patterns to a system for testing or simulating an integrated circuit;  
           [0016]    (b) applying the set of test patterns to a neural network;  
           [0017]    (c) comparing outputs of the system for testing or simulating the integrated circuit and outputs of the neural network for providing a comparison result; and  
           [0018]    (d) adapting parameters of the neural network to approximate a behavior of the integrated circuit based the comparison result.  
           [0019]    In particular, the system for testing or simulating the integrated circuit may be an automatic test equipment (ATE), and the set of test patterns is applied to the integrated circuit via the automatic test equipment. The neural network may be integrated in the ATE. It may be implemented using any known ATE.  
           [0020]    The invention is based on the idea that the dynamic behavior of the integrated circuit device can be learnt from a set of random test patterns using a neural network.  
           [0021]    This mode of operation of the neural network can be referred to as learning mode.  
           [0022]    After the learning process has been completed, the ATE is able to perform test pattern classification. The ATE may thus select sub-optimal patterns for subsequent simulation or testing of the integrated circuit. The selected test patterns sufficiently approximate worst case scenarios.  
           [0023]    Another mode of the invention includes implementing the neural network in the automatic test equipment.  
           [0024]    Yet another mode of the invention includes generating the set of test patterns on a random basis.  
           [0025]    According to a another mode of the invention, step (d) includes adapting inter-unit weights of the neural network through back-propagation.  
           [0026]    Yet another mode of the invention includes repeating steps (a) to (d) until a level of adaptation in step (d) falls below a given value.  
           [0027]    A further mode of the invention includes storing data representing predetermined neural network parameters after terminating a repetition of steps (a) to (d).  
           [0028]    With the objects of the invention in view there is also provided, a method of selecting test patterns, the method includes the steps of:  
           [0029]    (a) approximating a behavior of an integrated circuit by applying a set of test patterns to a system for testing or simulating the integrated circuit, applying the set of test patterns to a neural network, comparing outputs of the system for one testing and simulating the integrated circuit and outputs of the neural network for providing a comparison result, and adapting parameters of the neural network in order to approximate the behavior of the integrated circuit based the comparison result;  
           [0030]    (b) applying a test pattern to the neural network whose parameters have been adapted to approximate the behavior of the integrated circuit in accordance with step (a);  
           [0031]    (c) processing an output of the neural network to determine whether given criteria are met; and  
           [0032]    (d) selecting the test pattern for storage if the given criteria are met.  
           [0033]    In other words, the invention also provides for a method of selecting test patterns, the method including the steps of:  
           [0034]    (a) applying a test pattern to a neural network whose parameters have been adapted to approximate the behavior of an integrated circuit according to the above described method;  
           [0035]    (b) processing the output of the neural network to determine whether predetermined criteria are met; and  
           [0036]    (c) selecting for storage the test pattern if the predetermined criteria are met.  
           [0037]    Using this method, a sufficient number of test patterns are provided for an efficient simulation or testing of the integrated circuit.  
           [0038]    This mode of operation of the neural network can be referred to as operation mode.  
           [0039]    A further mode of the invention includes repeating steps (b) to (d) until a given number of test patterns have been stored.  
           [0040]    Another mode of the invention includes concluding that the given criteria are met if a value of a given parameter of a signal output by the neural network in response to applying the test pattern exceeds a reference value.  
           [0041]    A further mode of the invention includes the steps of:  
           [0042]    (e) applying a further set of test patterns to the integrated circuit by using an automatic test equipment;  
           [0043]    (f) measuring values of the given parameter of output signals generated by the integrated circuit in response to step (e); and  
           [0044]    (g) concluding that the given criteria are met if the value of the given parameter of the signal output by the neural network in response to applying a test pattern exceeds the reference value and all values measured in step (f).  
           [0045]    A further mode of the invention includes the step of generating the further set of test patterns on a random basis.  
           [0046]    A further mode of the invention includes the step of using a dynamic current as the given parameter.  
           [0047]    A further mode of the invention includes the steps of:  
           [0048]    (h) generating a test pattern population formed of a plurality of test patterns;  
           [0049]    (i) applying each test pattern of the test pattern population to the neural network;  
           [0050]    (j) processing, for each test pattern, the output of the neural network to determine a value of a given parameter; and  
           [0051]    (k) allocating each test pattern to one of a plurality of classification groups in accordance with the value of the given parameter determined in step (j).  
           [0052]    A further mode of the invention includes repeating steps (h) to (k) using a new test pattern population formed of test patterns included in a selected one of the classification groups.  
           [0053]    A further mode of the invention includes the step of using, as the selected one of the classification groups, test patterns that approximate a set of worst case input parameters of operation of the integrated circuit.  
           [0054]    Another mode of the invention includes repeating steps (b) to (d) a number of times; applying the test patterns selected in each step (d) to a simulator for simulating the integrated circuit; processing an output of the simulator to determine whether further given criteria are met; and selecting for storage those test patterns that meet the further given criteria.  
           [0055]    A further mode of the invention includes repeating steps (b) to (d) a number of times; applying test patterns selected in each repetition of step (d) to the integrated circuit by using an automatic test equipment; processing an output of the automatic test equipment to determine whether further given criteria are met; and selecting for storage those test patterns which meet the further given criteria.  
           [0056]    A further mode of the invention includes the step of using, as the given criteria, a representation of an approximation of a worst case mode of operation of the integrated circuit.  
           [0057]    With the objects of the invention in view there is also provided, a method of simulating an integrated circuit, the method includes the steps of:  
           [0058]    selecting test patterns by, in a first step, applying a test pattern to a neural network whose parameters have been adapted to approximate a behavior of an integrated circuit by applying a set of test patterns to a system for testing or simulating the integrated circuit, applying the set of test patterns to a neural network, and comparing outputs of the system for testing or simulating the integrated circuit and outputs of the neural network, and, in a second step, processing an output of the neural network to determine whether given criteria are met and selecting a test pattern if the given criteria are met; and  
           [0059]    applying test patterns that have been selected to a simulator for simulating the integrated circuit.  
           [0060]    More generally, there is provided a method of simulating an integrated circuit, the method including the steps of applying test patterns that have been selected according to the above described method of selecting test patterns to a simulator for simulating an integrated circuit.  
           [0061]    With the objects of the invention in view there is also provided, a method of testing an integrated circuit, the method including the steps of:  
           [0062]    selecting test patterns by, in a first step, applying a test pattern to a neural network whose parameters have been adapted to approximate a behavior of an integrated circuit by applying a set of test patterns to a system for testing or simulating the integrated circuit, applying the set of test patterns to a neural network, and comparing outputs of the system for testing or simulating the integrated circuit and outputs of the neural network, and, in a second step, processing an output of the neural network to determine whether given criteria are met and selecting a test pattern if the given criteria are met; and  
           [0063]    applying test patterns that have been selected to the integrated circuit by using an automatic test equipment.  
           [0064]    Accordingly, there is also provided a method of testing an integrated circuit, the method including the steps of applying test patterns that have been selected according to the above described method of selecting test patterns to the integrated circuit using automatic test equipment (ATE).  
           [0065]    According to a preferred embodiment of the invention, the test patterns that have been selected in accordance with the above described neural network-based approach are further optimized using a genetic algorithm.  
           [0066]    With the objects of the invention in view there is also provided, a method of providing a test pattern for one of a simulation and a test of a layout of an integrated circuit, the method includes the steps of:  
           [0067]    (A) providing a set of test patterns that have been selected by, in a first step, applying a test pattern to a neural network whose parameters have been adapted to approximate a behavior of an integrated circuit by applying a set of test patterns to a system for testing or simulating an integrated circuit, applying the set of test patterns to a neural network, and comparing outputs of the system for testing or simulating the integrated circuit and outputs of the neural network, and, in a second step, processing an output of the neural network to determine whether given criteria are met and selecting a test pattern if the given criteria are met; and  
           [0068]    (B) applying the set of test patterns to the integrated circuit by using an automatic test equipment (ATE);  
           [0069]    (C) determining outputs of the integrated circuit;  
           [0070]    (D) processing the outputs to determine whether given test criteria are met; and  
           [0071]    (E) depending on a determination in step (D), generating a new set of test patterns based on the set of test patterns provided by step (A) by using a genetic algorithm.  
           [0072]    In other words, there is provided a method of providing a test pattern for the simulation and/or test of the layout of an integrated circuit, the method including the steps of:  
           [0073]    providing a set of test patterns consisting of test patterns selected in accordance with the above described method of selecting test patterns;  
           [0074]    applying the set of test patterns to the integrated circuit using automatic test equipment (ATE);  
           [0075]    determining the outputs of the integrated circuit;  
           [0076]    processing the outputs to determine whether predetermined test criteria are met; and  
           [0077]    depending on the determination in the processing step, generating a new set of test patterns on the basis of the set of test patterns provided by the step of providing the set of test patterns using a genetic algorithm.  
           [0078]    This combination of neural network- and genetic algorithm-based approaches further increases the chances of finding test patterns that sufficiently approximate worst case scenarios of operation of the integrated circuit.  
           [0079]    The method employs a genetic algorithm (optimization method) to optimize a set of pre-selected patterns based on measurements using an ATE. Thereby, a set of worst case noise patterns can be selected automatically. By using ATE for the processing of the test patterns, performance is greatly enhanced compared to approaches based on simulation.  
           [0080]    Test patterns generated accordingly can additionally be re-simulated for further detail design analysis and improvement.  
           [0081]    The genetic algorithm approach can be implemented using existing ATEs.  
           [0082]    A further mode of the method according to the invention includes repeating steps (B) to (E) until the given test criteria are met.  
           [0083]    A further mode of the method according to the invention includes repeating steps (B) to (E) until the given test criteria are met or repeating steps (B) to (E) a given number of times.  
           [0084]    A further mode of the method according to the invention includes the step of concluding that the given test criteria are met if the set of test patterns is associated with an average fitness above a given value.  
           [0085]    According to another mode of the invention step (E) includes combining some or all of the test patterns according to the genetic algorithm in order to provide the new set of test patterns.  
           [0086]    A further mode of the method according to the invention includes the step of selecting test patterns from the set of test patterns according to given selection criteria in order to provide selected test patterns; and combining the selected test patterns according to the genetic algorithm to provide the new set of test patterns.  
           [0087]    A further mode of the method according to the invention includes the step of selecting a test pattern if the test pattern is associated with a fitness value greater than a reference value.  
           [0088]    A further mode of the method according to the invention includes the step of selecting a test pattern if the test pattern is associated with a highest fitness value of all unselected test patterns.  
           [0089]    Another mode of the method according to the invention includes the step of selecting a test pattern if the test pattern is associated with a highest fitness value of all unselected test patterns, and repeating the selecting step until a given percentage of test patterns has been selected.  
           [0090]    According to another mode of the invention step (E) includes:  
           [0091]    (F) sorting selected test patterns according to an order of associated fitness values;  
           [0092]    (G) randomly selecting parent test patterns from test patterns as sorted in step (F); and  
           [0093]    (H) combining selected ones of the parent test patterns.  
           [0094]    A further mode of the method according to the invention includes the step of using a mutation, a crossing over, and/or a re-combination for the genetic algorithm.  
           [0095]    According to another mode of the invention the step (A) includes providing a plurality of sets of test patterns such that each of the sets of test patterns is included in a test pattern population.  
           [0096]    A further mode of the method according to the invention includes the step of providing a plurality of test pattern populations and performing steps (B) to (E) for each of the test pattern populations.  
           [0097]    With the objects of the invention in view there is also provided, a data processing configuration, including:  
           [0098]    a system for testing or simulating an integrated circuit, said system being configured to be supplied with a set of test patterns;  
           [0099]    a neural network operatively connected to said system for testing or simulating the integrated circuit, said neural network being configured to be provided with the set of test patterns;  
           [0100]    a comparison unit operatively connected to said neural network and said system for testing or simulating the integrated circuit, said comparison unit being configured to compare outputs from said system for testing or simulating the integrated circuit and from said neural network in order to provide a comparison result; and  
           [0101]    an adapting unit operatively connected to said comparison unit, said adapting unit being configured to adapt parameters of said neural network in order to approximate a behavior of the integrated circuit based the comparison result.  
           [0102]    With the objects of the invention in view there is also provided, a computer-readable medium having computer-executable instructions for performing a method which includes the steps of:  
           [0103]    applying a set of test patterns to a system for testing or simulating an integrated circuit;  
           [0104]    applying the set of test patterns to a neural network;  
           [0105]    comparing outputs of the system for testing or simulating the integrated circuit and outputs of the neural network for providing a comparison result; and  
           [0106]    adapting parameters of the neural network to approximate a behavior of the integrated circuit based the comparison result.  
           [0107]    More generally, according to the invention, there is provided a computer program for performing any of the methods according to the invention and a data processing system, adapted to perform any of the methods according to the invention.  
           [0108]    Other features which are considered as characteristic for the invention are set forth in the appended claims.  
           [0109]    Although the invention is illustrated and described herein as embodied in method of processing test patterns for an integrated circuit, it is nevertheless not intended to be limited to the details shown, since various modifications and structural changes may be made therein without departing from the spirit of the invention and within the scope and range of equivalents of the claims.  
           [0110]    The construction and method of operation of the invention, however, together with additional objects and advantages thereof will be best understood from the following description of specific embodiments when read in connection with the accompanying drawings. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0111]    [0111]FIG. 1 is a schematic illustration of a classification of three groups of test patterns;  
         [0112]    [0112]FIG. 2 is a flow chart illustrating a process representing the neural network learning mode according to an embodiment of the invention;  
         [0113]    [0113]FIG. 3 is a flow chart illustrating a process representing the neural network operation mode according to an embodiment of the invention;  
         [0114]    [0114]FIG. 4 is a schematic flow chart of a genetic algorithm using an initial random pattern generation according to the invention; and  
         [0115]    [0115]FIG. 5 is a flow chart illustrating a method combining a neural network-based pre-selection of test patterns and a subsequent optimization using a genetic algorithm according to the invention.  
     
    
     DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0116]    In accordance with one embodiment of the invention, a neural network model is implemented into the ATE. That is, the ATE is able to learn automatically from test runs of an integrated circuit performed on the ATE. After training of the neural network has been completed, it is able to identify which group of test patterns belong to a sub-optimal set. For this purpose, some million test patterns are selected vie the neural network. Subsequently, the pre-selected sub-optimal pattern is simulated (simulation approach) or measured (ATE approach) to further determine which of the patterns fulfill predetermined criteria. Those patterns which fulfill the criteria are selected for storage.  
         [0117]    [0117]FIG. 1 illustrates schematically a classification of three groups of patterns. Since the simulation approach- or ATE approach-based selection of patterns is performed on the basis of a sub-optimal set of patterns (group C), the speed and efficiency compared to conventional methods for identifying suitable test patterns is considerably improved. This approach is referred to as maximum approximation.  
         [0118]    Suppose, as illustrated in FIG. 1, there are P N ∈{P N   A  P N   B  P N   C }, N&gt;0, three groups of test patterns within a full range of all possible test patterns. Instead of searching through all possible patterns, the neural network may learn and distinguish between different groups of test patterns using an ATE-based training program. Accordingly, the test patterns are pre-classified.  
         [0119]    In the maximum approximation algorithm mode, the sub-optimal set P N   C  and P N   B ∩P N   C  are generated based on neural network decisions, and a sub-optimal pattern set forms a new pattern population.  
         [0120]    This process can be repeated iteratively on the basis of the new pattern population, thereby to select the best group of patterns out of the sub-optimal population, and so on.  
         [0121]    A neural network is an interconnected assembly of simple processing elements, units or nodes, whose functionality is loosely based on that of the animal neuron. The network ability of the network is stored in the inter-unit connection strengths, or weights, obtained by a process of adaptation to, or learning from, a set of training patterns.  
         [0122]    [0122]FIG. 2 illustrates a process representing the neural network learning mode according to an embodiment of the invention. The neural network is based on back-propagation net characteristics to perform a pattern classification task. In the beginning, the neural network learns from a set of random patterns. The test results are supervised by a test system (ATE). The learning process is terminated when the learning error is less than a predetermined value. Subsequently, a neural network learning weight (“brain”) file is generated. This file is then used in operation mode to perform a pattern classification task.  
         [0123]    [0123]FIG. 3 illustrates a process representing the neural network operation mode according to an embodiment of the invention. In the operation mode, the neural network is able to perform pattern classification based on previous learning experience (contained in the NN brain file) for pattern approximation and selection. The procedure of pattern selection may be based on a very small set of NN pattern populations. For example, one NN pattern population may include six NN decision patterns. The neural network first determines whether any pattern out of these six NN decision patterns belong to a potential maximum current group (sub-optimal group). If yes, then this pattern is selected. If no, then the search is repeated using the same procedure. In the final network classification, only those patterns are selected which cause a higher dynamic current than patterns that have been tested in real measurements (RSMA). For example, using this approach, 6*100=600 patterns can be classified, of which only 100 patterns require testing through measurement to determine if they cause higher dynamic currents, while the other 500 patterns are classified by the neural network.  
         [0124]    An implementation of the neural network pattern learning process and the neural network pattern classification process is given in Annex 1 and Annex 2, respectively.  
         [0125]    In one embodiment of the invention, the neural network is a back-propagation neural network. Back-propagation is a supervised learning algorithm mainly used by multi-layer-perceptrons in order to change the weights associated with the net&#39;s hidden neuron layer(s).  
         [0126]    Another embodiment of the invention will now be described by reference to FIGS. 4 and 5. In this embodiment, test patterns selected by the neural network are further optimized using a genetic algorithm.  
         [0127]    For the purposes of illustration, FIG. 4 shows a schematic flow diagram of a genetic algorithm without pre-selection of test patterns by a neural network (instead, the initial patterns are generated on a random basis).  
         [0128]    [0128]FIG. 5 illustrates a schematic flow diagram of a method combining neural network-based pre-selection of test patterns and subsequent optimization using a genetic algorithm, in accordance with an embodiment of the invention.  
         [0129]    Genetic algorithms are based on the principles of natural selection. In particular, genetic algorithms are stochastic search methods which simulate natural biological evolution. The algorithms operate on the basis of a population of potential solutions and, applying the principle of “survival of the fittest” to these potential solutions, produce a better approximation of a target solution in each iteration of the algorithm.  
         [0130]    Each iteration of the algorithm produces a new generation of approximations. The approximations of each generations are created by the process of selecting individuals according to their level of “fitness” in the problem domain. The selected individuals are bred with one another using operators borrowed from natural genetics. This process leads to the evolution of populations of individuals that are better suited for their environment than the individuals from which they were created, just as in natural adaptation.  
         [0131]    Accordingly, genetic algorithms model natural processes such as selection, cross over, recombination and mutation.  
         [0132]    [0132]FIG. 4 shows a method for detecting the worst case current consumption/peak current pattern (RSMA) based on a genetic algorithm. This method operates on the basis of populations of individual patterns instead of a single pattern solution. In this way, the search for better approximations can be performed in a parallel manner. Therefore, this method is more efficient than single pattern searching processes using dynamic random algorithm methods.  
         [0133]    Genetic algorithms may be employed for the simulation of an integrated circuit design in order to solve the worst case pattern search problem. The efficiency of genetic searching procedures is largely dependent on the number of pattern populations and the number of test patterns in each pattern population. However, as indicated above, the simulation-based approach forms a limitation if genetic algorithms are to be employed. The genetic selection procedure has to evaluate every “fitness” (dynamic peak/averaged current) of the test patterns in each pattern population. For example, there may be 200 pattern populations each including 20 patterns. Thus, the genetic algorithm has to evaluate the fitness of 200*20=4,000 patterns. If each test pattern is a 50 cycles test pattern which requires 30 minutes of simulation time (e.g. EPIC or SPICE simulator), then the total required searching and simulation time is 4,000*30 minutes=120,000 minutes, i.e. approximately 83 days of non stop simulation in order to process 200 pattern populations only.  
         [0134]    In addition, the full pattern combination domain increases proportionally to the complexity of VLSI (Very Large-Scale Integration) or ULSI (Ultra Large Scale Integration) designs. Therefore, a subset of 200 pattern populations is only a very small subset of the full pattern combination domain.  
         [0135]    In contrast, when using a genetic algorithm together with ATE, many more pattern populations per time unit can be processed. This is because the testing of an integrated circuit using ATE is considerably faster than simulation using conventional systems. Accordingly, the approximation of worst case test patterns in a given period of time is much more accurate.  
         [0136]    An implementation of a dynamic genetic algorithm for use with ATE is presented in the following. At the beginning of the computation, a number of individual random patterns 
           P   N   POP =( p   1   ,p   2   , . . . , p   N )  (1) 
         [0137]    are randomly generated and initialized, wherein N is the maximum number of random patterns and POP is the maximum number of pattern populations.  
         [0138]    Subsequently, for each individual pattern (p 1 , p 2 , . . . , p N ), the objective functions 
           I   peak (∀ I   sample ( P   N   , SRMS ))  (2) 
         and 
           I   averaged ( P   N   , SRMS )  (3) 
         [0139]    are evaluated using equation (4):  
                     I   Measurement          (       P   N     ,   T     )       =           V   DD          (       P   N     ,   T     )         R   eff       +       1     L   eff              ∫     T   min       T   max                V   DD          (       P   N     ,   T     )               T           +     Δ                     I   CMOS          (       P   N     ,   T     )             ,     ∀   T     ,       P   N     &gt;   0            
          T   =       SRMS        (       T   min     ,     T   max       )       ⇒     Random_Float      _Number                   (       T   min     ,     T   max       )                
              T   max     ≥     T   min       ,     ∀     T   min       ,       T   max     &gt;   0     ,         I   Measurement          (       P   N     ,   T     )       ∈     {       I   peak                     I   averaged       }                 (   4   )                               
 
         [0140]    The first (initial) generation is thus produced, and the averaged fixness of the individual patterns (p 1 , p 2 , . . . , p N ) is calculated using equation (5):  
                 Averaged_Fixness                   (     Fixness                   (     P   N   POP     )       )       =         ∑     N   =   O     N            I   Measurement          (     P   N     )             Fixness                   (     P   N     )       =         I   Measurement   N          (       P   N     ,   T     )       ∈     {       I   peak                     I   averaged       }             ,   N   ,       P   N     &gt;   0             (   5   )                               
 
         [0141]    If the optimization criteria  
             (       Averaged_Fixness                   (       I   Measurement          (     P   N   POP     )       )       &lt;     I   MAX_REF       )           (   6   )                               
 
         [0142]    is not met for any existing population, a new population is created on the basis of the existing population. Individual patterns are selected according to their fitness for the production of offspring (loop 1  in FIG. 4).  
         [0143]    In this selection approach, the basic concept of tournament selection is employed. That is, only the best individual pattern from the existing population is selected as a parent. This process is repeated until a pre-defined percentage of best patterns has been selected:  
                 Sorting                   (         I   Measurement          (     P   N     )       ∈     {         I   min          (     P     N   min       )                     …                   I   max                     (     P     N   max       )       }       )       ⇒     Parent                   (       I   Measurement          (     P   N     )       )              
          N   ∈       {       N   min                     N   max       }                   N     ∈     {       N   min     =       N   max     -       (       N   max     ×   B     )          N   max           }               (   7   )                               
 
         [0144]    wherein B is the pre-defined percentage of the best pattern group. The sorting function first re-arranges the test patterns from minimum to maximum according to their fixness values. Subsequently, the parent selection is generated in random sequence based on the new sub-optimal fixness range N, which is calculated using B. Parents (selected patterns) are combined using cross over ( 8 ), re-combined ( 9 ) and mutated ( 10 ) in order to produce offspring  
                     CrossOver                   (         P   N          (       C   1     ,     C   2       )       ,       P     N   +   1            (       C   3     ,     C   4       )         )              ⇒     Upper_CrossOver                   (         P   N          (       C   3     ,     C   2       )       ,       P     N   +   1            (       C   1     ,     C   4       )         )                            ⇒     Lower_CrossOver                   (         P   N          (       C   1     ,     C   4       )       ,       P     N   +   1            (       C   3     ,     C   2       )         )                              ⇒     Stripe_CrossOver                   (         P   N          (       C   4     ,     C   3       )       ,       P     N   +   1                       (       C   2     ,     C   1       )         )                       (   8   )                               
 
         [0145]    where C is the test pattern content which is selected for cross over of two patterns. In the cross over process, upper, lower or stripe cross over methods are performed in random sequence, and the contents of two cross over patterns are exchanged in order to produce two new offspring patterns.  
         [0146]    Thereafter, the re-combination equation (9) is used to select the best fixness pattern out of two new cross over offspring patterns: 
         [0147]    ti Recombination ( P   N   , P   N+1 )→ I   maximum ( P   N   , P   N+1 )→ I   Best ( P   M ),  N, M, P   N &gt;0  (9) 
         [0148]    [0148]                     Mutation                   (       P   M          (       C   1     ,     C   2     ,     C   3     ,       C   4                   …                   C   y         )       )              ⇒       P   M          (         C   1     +     R   1       ,       C   2     +     R   2       ,              …              ,       C   y     +     R   y         )                                ⇒     R   y       ∈     {       1                 0                -   1     }       ,   M   ,     P   M     ,     y   &gt;   0                     (   10   )                                 
         [0149]    where M is the number of new selected offspring patterns to form the new population. After recombination, the offspring undergoes mutation. Offspring variables are mutated by the addition of small random values 
           Ry ∈(1 0 −1)  (11) 
         [0150]    The mutation process helps to improve the optimization search process.  
         [0151]    Finally, all offspring patterns are inserted into the population, replacing the parents (original pattern population) and producing a new generation. This cycle (loop  1  in FIG. 4) is performed until the optimization criteria are met. If the fitness does not improve after a pre-defined number of genetic breeding generations, a new pattern population (loop  2  in FIG. 4) will be generated in random sequence. This combination greatly increases the chances of finding worst case test patterns.  
         [0152]    A complete implementation of this algorithm using ATE J973 is given in Annex 3.  
         [0153]    [0153]FIG. 5 illustrates a flow diagram of a method combining neural network-based pre-selection of test patterns and subsequent optimization using a genetic algorithm.  
         [0154]    A complete implementation of this combined approach using ATE J973 is given in Annex 4.  
         [0155]    It is to be noted that the invention is not restricted to the embodiments and implementations described herein but encompasses modifications and variations within the scope of the invention as determined from the claims.  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Annex 1: Neural Network Pattern Learning Implementation Using ATE J973                    Start Neural Network Training Using ATE. Circuit Initialization       Default AC/DC Specification Initialization.       DP Dummy Pattern: Vector Memory Initialization       INPUT. {N Vector_cycle DP Auto_Range ε G Epoch Max_Loop EX File_Name}       Check if Input valid?       else Input Error! exit(1).       For P1 = 0, 1,2,3,...,Auto_Range+1 do : (Automatic Input &amp; Output Range       Calculation)       {                                 Random_Pattern      _Generation     ⇒             P   ∈     (       p   1     ,     p   2     ,   …              ,     p   N       )       :                Random                 Pattern                 Population                               ∀   vector_cycle     ,     N   &gt;   0                                                                   X        (       P   N     ,       I     peak   /   averaged            (     P   N     )         )       ∈     {       X   1     ,       X   2                   …                   X   i         }       ,       X   offset     =       (       C   max     -     C   min       )     ×     R   offset         ,     R   offset     ,     i   &gt;   0                   X   1     ∈     {       X   min     =       X   min     +     X   offset         }                                                                   X   2     ∈     {       X   mid11     =         X   min     -     1                   X   mid12         =       X   min     +     X   offset           }                   X   3     ∈     {       X   mid21     =         X   mid12     -     1                   X   mid22         =       X   mid21     +     X   offset           }                   X   4     ∈     {       X   max     =       X   mid22     -   1       }                                                     }       Neural Network Training Loop:       {                                 Random_Pattern      _Generation     ⇒             P   ∈     (       p   1     ,     p   2     ,   …              ,     p   N       )       :                Random                 Pattern                 Population                               ∀   vector_cycle     ,     N   &gt;   0                                                         Vector_Code      _Matrix        (       P   N          (   Vector_Cycles   )       )       ⇒     [             P   0          (   Vector_Cycles   )                   P   1          (   Vector_Cycles   )               ⋮               P   N          (   Vector_Cycles   )             ]                                               P   N          (   Vector_Cycles   )       ∈         P   N          (       vector_encode        (     ∀   signal_bus     )       ,   Vector_Cycles     )                       (     ATE                 Training                 Set     )                                                     Pattern_Generator        (     Vector_Memory        (     P   N     )       )                 ⇒       Pattern_Controller        (     Vector_Memory        (     P   N     )       )        N     &gt;     0                   (     Pattern                 Executor     )                                                             Start                 Pattern                 Generator        :                       P   N          (       T   min     ,     T   max       )         ⇒   Dynamic_Pattern                                         Start Current Measurement &amp; Calculation:                                     I   Measurement          (       P   N     ,   T     )       =           V   DD          (       P   N     ,   T     )         R   eff       +       1     L   eff              ∫     T   min       T   max                V   DD          (       P   N     ,   T     )               T           +       ΔI   CMOS          (       P   N     ,   T     )           ,     ∀   T     ,       P   N     &gt;   0                 T   =       SRMS        (       T   min     ,     T   max       )       ⇒     Random_Float      _Number        (       T   min     ,     T   max       )                         T   max     ≥     T   min       ,     ∀     T   min       ,       T   max     &gt;   0                                                         Stop                 Pattern                 Generator        :                       P   N     :       I   peak          (     ∀       I   sample          (       P   N     ,   SRMS     )         )           ,       I   averaged          (       P   N     ,   SRMS     )                                                          Z k  = I Measurement (P N ,T)∈{I peak   I averaged }                                X   k          (       P   N     ,       I   Measurement          (     P   N     )         )       ∈       {           X   1   k           X   2   k         …         X   i   k           }                     (     Neural                 Network                 Learning                 Set     )                                                                            X   j     =       ∑   i            W   ji          a   i                       Y        (   X   )       =     1     1   +            -   X     ×   G                                                                         E   =       1   2            ∑     k   =   1     s            ∑     j   =   1     n              (       Y   j   k     -     Z   j   k       )     2                     (     Supervising                 Learning                 via                 ATE     )                             ∂   E       ∂     w   ji         =       ∑   k            (       Y   j   k     -     Z   j   k       )     ×       Y   j   k          (     1   -     Y   j   k       )       ×     X   i   k                                                                         w   ji     =       w   ji     -     ɛ   ×     (       ∂   E       ∂     w   ij         )     ×   G                     E        (     P   N     )       +=       E        (     P   N     )                       (     pattern                 population                 Learning                 Error                 calculation     )                                                     Training_Loop++            if (Training_Loop&gt;Epoch) (pattern population learning done)                       {     E   =       ∑     E        (     P   N     )         Epoch       }                                         if (Training_Loop&gt;Max_Loop)                {So Far Neural Network Learning File (File_Name) Generation, exit (1)}            If (E&gt;EX)                {Go To Neural Network Training Loop: Learn Again!! Initialize: E=0}            else                {expected Neural Network Learning File (File_Name) Generation, exit(1)}            } End of Neural Network Learning       Final Neural Network Learning Plot Generation       End of Neural Network Learning via ATE                    Annex 2: Neural Pattern Classification Implementation Using ATE J973                    Start NN_MA:   Circuit Initialization       Default AC/DC Specification Initialization.       DP Dummy Pattern: Vector Memory Initialization       INPUT: {N Vector_cycle DP Max_Loop File_Name}       Check if Input valid?       else Input Error! exit(1).       NN_Learning_File (File_Name)∈{ w ij  ε G X k }       NN_MA_Loop:       {                                                      Random_Pattern      _Generation     ⇒             P   ∈     (       p   1     ,     p   2     ,   …              ,     p   N       )       :                Random                 Pattern                 Population                               ∀   vector_cycle     ,     N   &gt;   0                                                                                    X   k          (       P   N     ,       I   Measurement          (     P   N     )         )       ∈       {           X   1   k           X   2   k         …         X   i   k           }                     (     Neural                 Network                 Learning                 Set     )                                                                            X   j     =       ∑   i            W   ji          a   i                       Y        (   X   )       =     1     1   +            -   X     ×   G                                                                 if        (     ∀         Y   N          (   X   )       &lt;     Y     sub_optional      _set           )                                       { Go to NN_MA_Loop : New Pattern Population Generation !!! }           else                           {       Sorting        (       P   N     ,       Y   N          (   X   )         )       ⇒       P   M                     (     Sub        -        optimal                 set                 based                 on                           neural                 network     )     }                                                                                Vector_Code      _Matrix        (       P   M          (   Vector_Cycles   )       )       ⇒     [             P   0          (   Vector_Cycles   )                   P   1          (   Vector_Cycles   )               ⋮               P   M          (   Vector_Cycles   )             ]                                   P M (Vector_Cycles)∈P M (vector_encode(∀signal_bus), Vector_Cycles))                                            Pattern_Generator        (     Vector_Memory        (     P   M     )       )                   ⇒       Pattern_Controller        (     Vector_Memory        (     P   M     )       )        M     &gt;     0                   (     Pattern                 Executor     )                                                                     Start                 Pattern                 Generator        :                       P   M          (       T   min     ,     T   max       )         ⇒   Dynamic_Pattern                                         Start Current Measurement &amp; Calculation:                             I   Measurement          (       P   M     ,   T     )       =           V   DD          (       P   M     ,   T     )         R   eff       +       1     L   eff              ∫     T   min       T   max                V   DD          (       P   M     ,   T     )               T           +       ΔI   CMOS          (       P   M     ,   T     )           ,     ∀   T     ,       P   M     &gt;   0                                                                                T   =       SRMS        (       T   min     ,     T   max       )       ⇒     Random_Float      _Number        (       T   min     ,     T   max       )                         T   max     ≥     T   min       ,     ∀     T   min       ,       T   max     &gt;   0                                                            Stop Pattern Generator: P M  : I peak (∀I sample (P M ,SRMS)), I averaged (P M ,SRMS)                I Measurement (P M ,T)∈{I peak   I averaged }                    NN_Max_Loop++(operating loop counted)                         Sorting        (       P   M     ,       I   Measuremet          (     P   M     )         )       ⇒       P   selscted                     (     best                 out                 of                 sub        -        optimal                 set                 via                 ATE     )                                             if(I Measurement (P selected )&gt;∀I Measurement (P previous     —   selected))                { Update VCM Database File }            if(NN_Max_Loop&lt;Max_Loop)                { Go to NN_MA_Loop : New Pattern Population Generation!!! }            else                { Final VCM Database File Generation exit(1)}            }       Final Neural Network Maximum Approximation Plot Generation.       End of NN_MA                    Annex 3: Dynamic Genetic Algorithm Implementation Using ATE J973                            Start D_GA: Circuit Initialization       Default AC/DC Specification Initialization.       DP Dummy Pattern: Vector Memory Initialization       INPUT: {N Vector_Cycles DP Loop1 Loop2 I Max     —   Ref}       Check if Input valid?       else Input Error! exit(1).       For POP = 0,1,2,3,...,Loop2+1 do:                {                                      Random_Pattern      _Generation     ⇒            P   ∈     (       p   1     ,     p   2     ,   …   ,     p   N       )                              ∀   vector_cycle     ,     N   &gt;   0                              P   N   POP     =       (       p   1     ,     p   2     ,     …                   p   N         )                   Initial                 Pattern                 Population                                                         For P1=0, 1, 2, 3, ..., N+1 do:                {                              Vector_Code      _Matrix        (       P   N          (   Vector_Cycles   )       )       ⇒     [             P   0          (   Vector_Cycles   )                   P   1          (   Vector_Cycles   )               ⋮               P   N          (   Vector_Cycles   )             ]                                                 P   N          (   Vector_Cycles   )       ∈       P   N          (       vector_encode        (     ∀   signal_bus     )       ,   Vector_Cycles     )                                                                  Pattern_Generator        (     Vector_Memory        (     P   N     )       )                 ⇒       Pattern_Controller        (     Vector_Memory        (     P   N     )       )        N     &gt;     0                   (     Pattern                 Executor     )                                                             Start                 Pattern                 Generator        :                       P   N          (       T   min     ,     T   max       )         ⇒   Dynamic_Pattern                                 Start Current Measurement &amp; Calculation:                       I   Measurement          (       P   N     ,   T     )       =           V   DD          (       P   N     ,   T     )         R   eff       +       1     L   eff              ∫     T   min       T   max                V   DD          (       P   N     ,   T     )               T           +       ΔI   CMOS          (       P   N     ,   T     )           ,     ∀   T     ,       P   N     &gt;   0                                                                              T   =       SRMS        (       T   min     ,     T   max       )       ⇒     Random_Float      _Number        (       T   min     ,     T   max       )                         T   max     ≥     T   min       ,     ∀     T   min       ,       T   max     &gt;   0                                                            Stop Pattern Generator: P N  : I peak (∀I sample (P N ,SRMS)), I averaged (P N , SRMS)                Fixness (P N ) = I Measurement  (P N , T)∈{I peak   I averaged }                }                                Averaged_Fixness                   (     Fixness                   (     P   N   POP     )       )       =         ∑     N   =   0     N            I   Measurement          (     P   N     )         N       ,   N   ,       P   N     &gt;   0                                           if                   (       Averaged_Fixness                   (       I   Measurement          (     P   N   POP     )       )       &gt;     I   Max_Ref       )                                                        {Final VCM Generation (Database 1) exit (1) }                    For P2 = 0, 1, 2, 3, . . . Loopl+1 do:                {                                    Sorting        (         I   Meaurement          (     P   N     )       ∈            {         I   min          (     P     N   min       )                     …                     I   max          (     P     N   max       )         }       )             ⇒     Parent                   (       I   Measurment          (     P   N     )       )                   N   ∈            {       N   min                     N   max       }             N   ∈     {       N   min     =       N   max     -       (       N   max     ×   B     )                     N   max           }                                                                 CrossOver                   (         P   N          (       C   1     ,     C   2       )       ,       P     N   +   1            (       C   3     ,     C   4       )         )       ⇒            Upper_CrossOver                   (         P   N          (       C   3     ,     C   2       )       ,       P     N   +   1            (       C   1     ,     C   4       )         )                   ⇒            Lower_CrossOver                   (         P   N          (       C   1     ,     C   4       )       ,       P     N   +   1            (       C   3     ,     C   2       )         )                   ⇒            Stripe_CrossOver                   (         P   N          (       C   4     ,     C   3       )       ,       P     N   +   1            (       C   2     ,     C   1       )         )                                                             Recombination                   (       P   N     ,     P     N   +   1         )       ⇒       I   maximum          (       P   N     ,     P     N   +   1         )       ⇒       I   Best          (     P   M     )         ,   N   ,   M   ,       P   N     &gt;   0                                                     Mutation                   (       P   M          (       C   1     ,     C   2     ,     C   3     ,       C   4                   …                   C   y         )       )       ⇒              P   M          (         C   1     +     R   1       ,       C   2     +     R   2       ,       …                   C   y       +     R   y         )                     ⇒              R   y     ∈     {       1                 0                -   1     }         ,   M   ,     P   M     ,     y   &gt;   0                                               For P3 =0,1,2,3,..., M+1 do:                {                                                 Pattern_Generator        (     Vector_Memory        (     P   M     )       )                   ⇒       Pattern_Controller        (     Vector_Memory        (     P   M     )       )        M     &gt;     0                   (     Pattern                 Executor     )                                                             Start                 Pattern                 Generator        :                       P   M          (       T   min     ,     T   max       )         ⇒   Dynamic_Pattern                                 Current Measurement &amp; Calculation:                     I   Measurement          (       P   M     ,   T     )       =           V   DD          (       P   M     ,   T     )         R   eff       +       1     L   eff              ∫     T   min       T   max                V   DD          (       P   M     ,   T     )               T           +       ΔI   CMOS          (       P   M     ,   T     )           ,     ∀   T     ,       P   M     &gt;   0                                                                        T   =       SRMS        (       T   min     ,     T   max       )       ⇒     Random_Float      _Number        (       T   min     ,     T   max       )                         T   max     ≥     T   min       ,     ∀     T   min       ,       T   max     &gt;   0                                                    Stop Pattern Generator: P M  : I peak (∀I sample (P M , SRMS)), I averaged (P M ,SRMS)                Fixness (P M )=I Measurement (P M ,T)∈{I peak   I averaged }                {                                Averaged_Fixness                   (     Fixness                   (     P   M   POP     )       )       =         ∑     M   =   0     M            I   Measurement          (     P   M     )         M       ,   M   ,       P   M     &gt;   0                                           if                   (       Averaged_Fixness                   (       I   Measurement          (     P   M   POP     )       )       &gt;     I   Max_Ref       )                                            {Worst Case Pattern Found : Final VCM Generation(Database 1)exit(1)}           } End Of Loop 1            } End of Loop 2       Update So Far Worst Case Pattern Found : Final VCM Generation (Database 1)       End of D_GA                            Annex 4: Combined Neural Network Pattern Classification and Dynamic Genetic       Algorithm Implementation Using ATE J973                    Start NN GA. Circuit Initialization       Default AC/DC Specification Initialization.       DP Dummy Pattern: Vector Memory Initialization       INPUT. {N Vector_cycle DP Max_Loop Loop1 I Max     —   REF File_Name}       Check if Input valid?       else Input Error! exit(1).       NN_Learning File (File_Name)∈{w ij  ε G X k }       NN_GA_Loop:                {                                      Random_Pattern      _Generation     ⇒             P   ∈     (       p   1     ,     p   2     ,   …              ,     p   N       )       :                Random                 Pattern                 Population                               ∀   vector_cycle     ,     N   &gt;   0                                                           X   k          (       P   N     ,       I   Measurement          (     P   N     )         )       ∈       {           X   1   k           X   2   k         …         X   i   k           }                     (     Neural                 Network                 Learning                 Set                                                                              X   j     =       ∑   i            W   ji          a   i                         Y   N          (   X   )       =     1     1   +            -   X     ×   G                                                                 if                   (     ∀         Y   N          (   X   )       &lt;     Y     sub_optimal      _set           )                                        { Go to NN_MA_Loop: New Pattern Population Generation!!! }           else                             Sorting                   (       P   N            Y   N          (   X   )         )       ⇒       P   M          (     sub        -        optimal                 set                 based                 on                 neural                 network     )                                  P   M     ⇒       P   N                (     replacing                 the                 old                 population                 with                 new                 sub        -        optimal                 set     )                                                                  For P1 = 0,1,2,3,..., Loop1+ 1 do : (Start genetic algorithm to further improve sub-       optimal set)                {                                      Sorting        (         I   Meaurement          (     P   N     )       ∈            {         I   min          (     P     N   min       )                     …                     I   max          (     P     N   max       )         }       )       ⇒     Parent                   (       I   Measurment          (     P   N     )       )                   N   ∈            {       N   min                     N   max       }                 N   ∈            {       N   min     =       N   max     -       (       N   max     ×   B     )                     N   max           }                                                                 CrossOver                   (         P   N          (       C   1     ,     C   2       )       ,       P     N   +   1            (       C   3     ,     C   4       )         )       ⇒            Upper_CrossOver                   (         P   N          (       C   3     ,     C   2       )       ,       P     N   +   1            (       C   1     ,     C   4       )         )                   ⇒            Lower_CrossOver                   (         P   N          (       C   1     ,     C   4       )       ,       P     N   +   1            (       C   3     ,     C   2       )         )                   ⇒            Stripe_CrossOver                   (         P   N          (       C   4     ,     C   3       )       ,       P     N   +   1            (       C   2     ,     C   1       )         )                                                             Recombination                   (       P   N     ,     P     N   +   1         )       ⇒       I   maximum          (       P   N     ,     P     N   +   1         )       ⇒       I   Best          (     P   M     )         ,   N   ,   M   ,       P   N     &gt;   0                                                     Mutation                   (       P   M          (       C   1     ,     C   2     ,     C   3     ,       C   4                   …                   C   y         )       )       ⇒              P   M          (         C   1     +     R   1       ,       C   2     +     R   2       ,       …                   C   y       +     R   y         )                     ⇒              R   y     ∈     {       1                 0                -   1     }         ,   M   ,     P   M     ,     y   &gt;   0                                               For P3 =0,1,2,3,..., M+1 do:                {                                                 Pattern_Generator        (     Vector_Memory        (     P   M     )       )                   ⇒       Pattern_Controller        (     Vector_Memory        (     P   M     )       )        M     &gt;     0                   (     Pattern                 Executor     )                                                             Start                 Pattern                 Generator        :                       P   M          (       T   min     ,     T   max       )         ⇒   Dynamic_Pattern                                 Current Measurement &amp; Calculation:                     I   Measurement          (       P   M     ,   T     )       =           V   DD          (       P   M     ,   T     )         R   eff       +       1     L   eff              ∫     T   min       T   max                V   DD          (       P   M     ,   T     )               T           +       ΔI   CMOS          (       P   M     ,   T     )           ,     ∀   T     ,       P   M     &gt;   0                                                                        T   =       SRMS        (       T   min     ,     T   max       )       ⇒     Random_Float      _Number        (       T   min     ,     T   max       )                         T   max     ≥     T   min       ,     ∀     T   min       ,       T   max     &gt;   0                                                    Stop Pattern Generator: P M  : I peak (∀I sample (P M ,SRMS), I averaged  (P M , SRMS)                Fixness (P M ) = I Measurement  (P M ,T)∈{I peak   I averaged }                    {                           Averaged_Fixness                   (     Fixness                   (     P   M   POP     )       )       =         ∑     M   =   0     M            I   Measurement          (     P   M     )         M       ,   M   ,       P   M     &gt;   0                 if                   (       Averaged_Fixness                   (       I   Measurement          (     P   M   POP     )       )       &gt;     I   Max_Ref       )                                                                    {Worst Case Pattern Found : Final VCM Generation (Database 1) exit(1)}           { End of Loop 1            NN_Max_Loop++ (operatiang loop counter)       if (NN_Max_Loop &gt; Max_Loop)                { Go to NN_GA_Loop: New Pattern Population Generation!!!)                    else       {So Far Worst Case Pattern Found : Final VCM Generation (Database 1) exit(1)}       }       Final Neural Network_+ GA Plot Generation (Fig. 31)       End of NN+GA