C    ===================================================================
C	Slezak E. :	
C    ===================================================================

      parameter (
     1   NPtsM     =     3000,         ! Nb maximum de points
     1   NPMax     =        4 )        ! Nb maximum d'inconnues : ordre 3

       character
     1   Nom1*40,Nom2*40,Nom3*40

      real*8
     1   dA,dX,dP,dQ,dGALn

      real*4
     1   ValX(NPtsM),ValY(NPtsM),SigY(NPtsM),
     1   TabX(NPtsM),TabY(NPtsM),W(NPtsM),
     1   A(NPMax),SA(NPMax),
     1   rM(NPtsM)

      integer*4
     1   iC(NPtsM)

      logical*1
     1   Ponder

      Nom1    = 'e446.lco99.sL.match2'
      Nom2    = 'e446.lco99.sL.match2.fit3b'
      Nom3    = 'e446.lco99.sL.match2.calib3b'
      NParam  = 4                      ! ajustement de degre NParam-1
c      Ponder  = .True.
      Ponder  = .False.
      rK      = 2                      ! rejet a rK sigma
      NIter   = 2                      ! Nb de rejet a K sigma
      RFitMin = 13.0                   ! borne de l'intervalle d'ajustement
      RFitMax = 21.99                  ! borne de l'intervalle d'ajustement
      print *,' '
      print *,' ----------------------'
      if ( Ponder ) then
          print *,' Coefficients ajustes : WEIGHTED'
      else
          print *,' Coefficients ajustes : UNWEIGHTED / SANS'
      endif
      print *,' '
      print *,' Bornes de l ajustement : ',RFitMin,RFitMax
      print *,' ',NIter,' rejet(s) a ',rK,' sigma'
      print *,' '
C    -------------------------------------------------------------------
100   format ( 1x,i4,
     1         2x,i2,1x,i2,1x,f6.3,2x,i3,1x,i2,1x,f5.2,
     1         2x,f5.2,f5.2,2x,f4.2,
     1         3x,i2,1x,f7.1,
     1         3x,i6,
     1         2x,i2,1x,i2,1x,f6.3,2x,i3,1x,i2,1x,f5.2,
     1         2x,f5.2,f5.2,
     1         2x,f6.4,1x,i3 )
C    -------------------------------------------------------------------
      Lu1     = 1
      Lu2     = 2
      Lu3     = 3

      NIter  = NIter + 1               ! Nb de passages = 1 + Nb de rejets
      DO IParam = 1,NPMax
          A(IParam) = 0.
      ENDDO

      open (
     1   unit   = Lu1,
     1   file   = Nom1,
     1   status = 'old' )

      NPts = 0
      IPts = 0
1000  CONTINUE
          read (Lu1,100,end=1100) NumO,
     1                   iRAh,iRAm,rRAs,iDEd,iDEm,rDEs,
     1                   rMagR,EMagR,SIndex,
     1                   iCode,Distance,
     1                   N,
     1                   iRAhS,iRAmS,rRAsS,iDEdS,iDEmS,rDEsS,
     1                   R,E,
     1                   D,iFC

          NPts       = NPts + 1
          ValX(NPts) = R
          ValY(NPts) = rMagR - R
          SigY(NPts) = amax1( 0.001,EMagR+E )
          iC(NPts)   = iCode
          rM(NPts)   = R
          if ( iCode.ge.0 ) then
c          if ( iCode.ge.0 .and. iCode.le.1 ) then
            if ( R.ge.RFitMin .and. R.le.RFitMax ) then
              IPts       = IPts + 1
              TabX(IPts) = ValX(NPts)
              TabY(IPts) = ValY(NPts)
              Sigma      = SigY(NPts)
              if ( Ponder ) then
                  W(IPts) = 1./ ( Sigma*Sigma )
              else
                  W(IPts) = 1.
              endif
            endif
          endif

          goto 1000
1100  CONTINUE
      close (Lu1)
      NPtsI = IPts

      call LMS (A,SA,NParam,TabX,TabY,W,NPtsI,NIter,rK,NPtsF,rKhi2)

      print *,' Nombre initial de points de mesure : ',NPtsI
      print *,' Nombre final de points de mesure   : ',NPtsF
      print *,' '
      if ( NParam.ge.1 ) then
          print *,' Constante ......... : ',A(1),' +/- ',SA(1)
      endif
      if ( NParam.ge.2 ) then
          print *,' Pente ............. : ',A(2),' +/- ',SA(2)
      endif
      if ( NParam.ge.3 ) then
          print *,' Courbure .......... : ',A(3),' +/- ',SA(3)
      endif
      if ( NParam.ge.4 ) then
          print *,' Inflexion ......... : ',A(4),' +/- ',SA(4)
      endif

      dA = 0.5D0* dble( NPtsF-NParam )
      dX = 0.5D0* dble( rKhi2 )
      call GammaI (dP,dQ,dGALn,dA,dX)
      print *,' '
      print *,' Khi2 et probabilite : ',rKhi2/(NPtsF-NParam),sngl(dQ)
c      type *,' '
c      type *,' Ecart moyen residuel ',DeltaM
c      type *,' Fluctuation rms .....',Sigma
c      type *,' Mesures > K sigma ...',NObjS

      open (
     1    file   = Nom2,
     1    unit   = Lu2,
     1    status = 'new' )

      rMMin = 12
      rMMax = 22
      rMPas = 0.1
      MStep = 1 + int( (rMMax-rMMin)/rMPas )
      MStep = min0( MStep,NPtsM )
      DO IStep = 1,MStep
          rMag = rMMin + float(IStep-1)*rMPas
          X1         = rMag
          X2         = X1*X1
          X3         = X2*X1
          ValFit     = A(1) + A(2)*X1 + A(3)*X2 + A(4)*X3
          TabY(IStep) = ValFit - ValFit
          write (Lu2,*) rMag,ValFit,TabY(IStep)
      ENDDO
      close (Lu2)

      open (
     1    file   = Nom3,
     1    unit   = Lu3,
     1    status = 'new' )

      XMax = 0.
      if ( NParam.eq.3 ) XMax = -0.5* A(2)/A(3)
      if ( NParam.eq.4 ) then
           X1 =  4.*A(3)*A(3) - 12.*A(2)*A(4)
           if ( X1.ge.0. ) then
               Y1 = ( -2.*A(3) + sqrt( X1 ) ) / ( 6.*A(4) )
               Y2 = ( -2.*A(3) - sqrt( X1 ) ) / ( 6.*A(4) )
               if ( Y1.ge.13. .and. Y1.le.20. ) then
                   XMax = Y1
               else
                   XMax = Y2
               endif
           else
               XMax = 0.
           endif
      endif
      MPts = 0
      SY2  = 0.
      SY2G = 0.
      DO IPts = 1,NPts
          X1         = ValX(IPts)                   ! pas de troncature
c          X1         = amin1( ValX(IPts),XMax )     ! troncature droite
          X2         = X1*X1
          X3         = X2*X1
          X1G        = amax1( ValX(IPts),XMax )     ! troncature gauche
          X2G        = X1G*X1G
          X3G        = X2G*X1G
          if ( iC(IPts).ge.0
c          if ( iC(IPts).ge.0 .and. iC(IPts).le.1
     1        .and. rM(IPts).le.RFitMax) then            
            MPts       = MPts + 1
            ValFit     = A(1) + A(2)*X1 + A(3)*X2 + A(4)*X3
            ValFitG    = A(1) + A(2)*X1G + A(3)*X2G + A(4)*X3G
            TabY(IPts) = ValY(IPts) - ValFit
            rMCor      = ValX(IPts) + ValFit
            SY2        = SY2 + TabY(IPts)*TabY(IPts)
            SY2G = SY2G + (ValY(IPts)-ValFitG)*(ValY(IPts)-ValFitG)
            write (Lu3,*) rMCor,ValY(IPts),TabY(IPts)
          endif
      ENDDO
      close (Lu3)

      rmsG = sqrt( SY2G/float(MPts) )
      rms0 = sqrt( SY2/float(MPts) )
      print *,' rms scatter 1 : ',rms0
      MPts = 0
      SY2  = 0.
      DO IPts = 1,NPts
          if ( iC(IPts).eq.1 .and. abs(TabY(IPts)).lt.rms0 ) then
              MPts = MPts + 1
              SY2  = SY2 + TabY(IPts)*TabY(IPts)
          endif
      ENDDO
      rms1 = sqrt( SY2/float(MPts) )
      print *,' rms scatter 2 : ',rms1
      print *,' XMax : ',XMax
      print *,' rms scatter G : ',rmsG

C    ===================================================================
      end

C        1         2         3         4         5         6         7         8
C2345678901234567890123456789012345678901234567890123456789012345678901234567890
C    ===================================================================
      SubRoutine LMS(A,SA,NParam,TabX,TabY,Ws,NPtsI,NIter,rK,NPtsF,Khi2)
C
C     Ajustement par moindres carres d'un polynome de degre au plus trois
C     sur une ensemble de points dont les abscisses sont connues precisement.
C
C     A,SA,NParam         ! les NParam parametres de l'ajustement et leur incertitude
C     TabX,TabY           ! les points de coordonnees (X,Y)
C     Ws                  ! les poids statistiques (zero en retour si ecartes)
C     NPtsI               ! le nombre initial de points
C     NIter,rK,NPtsF      ! (NIter-1) rejets a rK sigma; la population finale
C     Khi2                ! le Khi2 de l'ajustement
C
C     Slezak E.   :  010612 :
C    ===================================================================

      parameter (
     1   NPtsM     =     3000,         ! Nb maximum de points
     1   NPMax     =        4 )        ! Nb maximum d'inconnues : ordre 3

      real*8
     1   dX1,dX2,dX3,dY,
     1   Sum(NPMax,NPMax+1),Coe(NPMax,NPMax+1),dA(NPMax),
     1   CMax,Coef,dVA(NPMax),
     1   dD1,dD2,dD3,dD4,dE1,dE2,dE3,dE4,dDeter

      real*4
     1   TabX(NPtsM),TabY(NPtsM),      ! Les coordonnees
     1   Ws(NPtsM),                    ! Le poids statistique : 1/Var
     1   DeltaFit(NPtsM),ValFit(NPtsM),DeltaF(NPtsM),
     1   A(NPMax),Variance(NPMax),SA(NPMax),
     1   Khi2

      integer*4
     1   iW(NPtsM),NDegLib(NPMax)      ! les objets conserves

      logical*1
     1   Unweighted

C    -------------------------------------------------------------------

      if ( NParam.lt.1 .or. NParam.gt.NPMax ) then
           NParam = NPMax
      endif
      N  = NPMax             ! Nb de lignes de la matrice = Nb d'inconnues
      N1 = N + 1             ! Le deuxieme membre du systeme : + 1 terme

      Unweighted = .True.    ! Les poids statistiques sont-ils egaux ?
      DO IPts = 1,NPtsI
          iW(IPts) = 1       ! Tous les objets interviennent initialement
          if ( Ws(IPts).ne.1. ) then
              Unweighted = .False.
          endif
      ENDDO
      DO IIter = 1,NIter
C    *******************************************************************

C    --- Calcul de toutes les sommes necessaires pour un ajustement ---
C    --- par moindres carres jusqu'a l'ordre NPMax-1 eventuellement ---

      DO I = 1,N
          DO J = 1,N1
              Sum(I,J) = 0.D0
          ENDDO
          dA(I)    = 0.D0
      ENDDO
      DO IPts = 1,NPtsI
          dX1      = dble( TabX(IPts) )
          dX2      = dX1*dX1
          dX3      = dX2*dX1
          dY       = dble( TabY(IPts) )

          Sum(1,1) = Sum(1,1) + Ws(IPts)
          Sum(1,2) = Sum(1,2) + Ws(IPts)* dX1
          Sum(1,3) = Sum(1,3) + Ws(IPts)* dX2
          Sum(1,4) = Sum(1,4) + Ws(IPts)* dX3
          Sum(1,5) = Sum(1,5) + Ws(IPts)* dY
          Sum(2,2) = Sum(2,2) + Ws(IPts)* dX1 * dX1 
          Sum(2,3) = Sum(2,3) + Ws(IPts)* dX2 * dX1
          Sum(2,4) = Sum(2,4) + Ws(IPts)* dX3 * dX1
          Sum(2,5) = Sum(2,5) + Ws(IPts)* dY  * dX1
          Sum(3,3) = Sum(3,3) + Ws(IPts)* dX2 * dX2
          Sum(3,4) = Sum(3,4) + Ws(IPts)* dX3 * dX2
          Sum(3,5) = Sum(3,5) + Ws(IPts)* dY  * dX2 
          Sum(4,4) = Sum(4,4) + Ws(IPts)* dX3 * dX3
          Sum(4,5) = Sum(4,5) + Ws(IPts)* dY  * dX3
      ENDDO
      Sum(2,1) = Sum(1,2)
      Sum(3,1) = Sum(1,3)
      Sum(3,2) = Sum(2,3)
      Sum(4,1) = Sum(1,4)
      Sum(4,2) = Sum(2,4)
      Sum(4,3) = Sum(3,4)


C    --- Transfert de la matrice SUM sur la matrice COE a triangulariser ---

      DO I = 1,NParam
          DO J = 1,NParam
              Coe(I,J) = Sum(I,J)
          ENDDO
          Coe(I,NParam+1) = Sum(I,5)
      ENDDO

C    =======================================================
C    === Debut de la triangularisation de la matrice Coe ===

      DO J = 1,NParam-1

C    --- Recherche du pivot de la colonne J : il s'agit d'eviter de diviser ---
C    --- par zero en permutant la ligne J avec celle ayant le coefficient   ---
C    --- le plus eleve, ceci afin de minimiser les erreurs d'arrondi.       ---

          CMax = dabs( Coe(J,J) )
          IMax = J
          DO I = J+1,NParam
              if ( dabs( Coe(I,J) ).gt.CMax ) then
                  CMax = dabs( Coe(I,J) )
                  IMax = I
              endif
          ENDDO
          if ( CMax.eq.0.D0 ) then
              print *,' '
              print *,'> Obtention d''un pivot nul pour la colonne :',J
              STOP
          endif
          DO K = J,NParam+1            ! Permutation des lignes J et IMax
              Coef        = Coe(J,K)
              Coe(J,K)    = Coe(IMax,K)
              Coe(IMax,K) = Coef
          ENDDO

C    --- Triangularisation : on fait apparaitre des 0 dans la colonne J     ---
C    --- pour les lignes J+1 a NParam en les remplacant par une combinaison ---
C    --- lineaire avec la ligne J.                                          ---

          DO I = J+1,NParam
              Coef = Coe(I,J) / Coe(J,J)
              DO K = 1,NParam+1                 ! Le 2eme membre est concerne
                  Coe(I,K) = Coe(I,K) - Coef * Coe(J,K)
              ENDDO
          ENDDO

      ENDDO

C    --- Resolution d'un systeme triangulaire ---

      dA(NParam) = Coe(NParam,NParam+1) / Coe(NParam,NParam)
      DO I = NParam-1,1,-1
          Coef = Coe(I,NParam+1)
          DO K = I+1,NParam
              Coef = Coef - Coe(I,K) * dA(K)
          ENDDO
          dA(I) = Coef / Coe(I,I)
      ENDDO

C    === Fin de la triangularisation de la matrice Coe  ===
C    ======================================================

C    --- Calcul de la variance de l'ajustement realise ---

      NPtsF   = 0
      Khi2    = 0.
      DeltaS  = 0.
      DO IPts = 1,NPtsI
          dX1    = dble( TabX(IPts) )
          dX2    = dX1*dX1
          dX3    = dX2*dX1
          ValFit(IPts) = sngl( dA(1) +dA(2)*dX1 +dA(3)*dX2 +dA(4)*dX3 )
          DeltaF(IPts) = TabY(IPts) - ValFit(IPts)
          Khi2   = Khi2   + Ws(Ipts)* DeltaF(IPts)*DeltaF(IPts)
          NPtsF  = NPtsF  + iW(IPts)
          DeltaS = DeltaS + float( iW(IPts) )* DeltaF(IPts)
      ENDDO
      DeltaM = DeltaS / float(NPtsF)
      rms = 0.
      DO IPts = 1,NPtsI
          Delta2 = ( DeltaF(IPts)-DeltaM )*( DeltaF(IPts)-DeltaM )
          rms    = rms + float( iW(IPts) )* Delta2
      ENDDO
      Sigma = sqrt( rms/float(NPtsF-1) )
      DTh   = rK * Sigma

      NObjS = 0
      DO IPts = 1,NPtsI
          if ( iW(IPts).eq.1 .and. abs(DeltaF(IPts)).gt.DTh ) then
              Ws(IPts) = 0.D0           ! Les objets a plus de K sigma seront
              iW(IPts) = 0              ! elimines.
              NObjS   = NObjS + 1
          endif
      ENDDO

      NDegLib(NParam)  = NPtsF - NParam ! cf. Snedecor
      Variance(NParam) = rms / float( NDegLib(NParam) )

      ENDDO                             ! Fin des rejets iteratifs
C    *******************************************************************

C    --- Incertitudes sur les parametres ---

      if ( NParam.eq.1 ) then
          dVA(1) = 1.D0 / Sum(1,1)
      endif
      if ( NParam.eq.2 ) then
          dDeter = Sum(1,1)*Sum(2,2) - Sum(1,2)*Sum(2,1)
          dVA(1) = Sum(2,2) / dDeter
          dVA(2) = Sum(1,1) / dDeter
      endif
      if ( NParam.eq.3 ) then
          dD1    = Sum(2,2)*Sum(3,3) - Sum(2,3)*Sum(3,2)
          dD2    = Sum(2,1)*Sum(3,3) - Sum(2,3)*Sum(3,1)
          dD3    = Sum(2,1)*Sum(3,2) - Sum(2,2)*Sum(3,1)
          dDeter = Sum(1,1)*dD1 - Sum(1,2)*dD2 + Sum(1,3)*dD3
          dVA(1) = dD1 / dDeter
          dVA(2) = ( Sum(1,1)*Sum(3,3) - Sum(1,3)*Sum(3,1) ) / dDeter
          dVA(3) = ( Sum(1,1)*Sum(2,2) - Sum(1,2)*Sum(2,1) ) / dDeter
      endif
      if ( NParam.eq.4 ) then
          dE1    = Sum(3,3)*Sum(4,4) - Sum(3,4)*Sum(4,3)
          dE2    = Sum(3,2)*Sum(4,4) - Sum(3,4)*Sum(4,2)
          dE3    = Sum(3,2)*Sum(4,3) - Sum(3,3)*Sum(4,2)
          dD1    = Sum(2,2)*dE1 - Sum(2,3)*dE2 + Sum(2,4)*dE3
          dE1    = Sum(3,3)*Sum(4,4) - Sum(3,4)*Sum(4,3)
          dE2    = Sum(3,1)*Sum(4,4) - Sum(3,4)*Sum(4,1)
          dE3    = Sum(3,1)*Sum(4,3) - Sum(3,3)*Sum(4,1)
          dD2    = Sum(2,1)*dE1 - Sum(2,3)*dE2 + Sum(2,4)*dE3
          dE1    = Sum(3,2)*Sum(4,4) - Sum(3,4)*Sum(4,2)
          dE2    = Sum(3,1)*Sum(4,4) - Sum(3,4)*Sum(4,1)
          dE3    = Sum(3,1)*Sum(4,2) - Sum(3,2)*Sum(4,1)
          dD3    = Sum(2,1)*dE1 - Sum(2,2)*dE2 + Sum(2,4)*dE3
          dE1    = Sum(3,2)*Sum(4,3) - Sum(3,3)*Sum(4,2)
          dE2    = Sum(3,1)*Sum(4,3) - Sum(3,3)*Sum(4,1)
          dE3    = Sum(3,1)*Sum(4,2) - Sum(3,2)*Sum(4,1)
          dD4    = Sum(2,1)*dE1 - Sum(2,2)*dE2 + Sum(2,3)*dE3
          dDeter = Sum(1,1)*dD1-Sum(1,2)*dD2+Sum(1,3)*dD3-Sum(1,4)*dD4
          dE1    = Sum(3,3)*Sum(4,4) - Sum(3,4)*Sum(4,3)
          dE2    = Sum(3,2)*Sum(4,4) - Sum(3,4)*Sum(4,2)
          dE3    = Sum(3,2)*Sum(4,3) - Sum(3,3)*Sum(4,2)
          dD1    = Sum(2,2)*dE1 - Sum(2,3)*dE2 + Sum(2,4)*dE3
          dE1    = Sum(3,3)*Sum(4,4) - Sum(3,4)*Sum(4,3)
          dE2    = Sum(3,1)*Sum(4,4) - Sum(3,4)*Sum(4,1)
          dE3    = Sum(3,1)*Sum(4,3) - Sum(3,3)*Sum(4,1)
          dD2    = Sum(1,1)*dE1 - Sum(1,3)*dE2 + Sum(1,4)*dE3
          dE1    = Sum(2,2)*Sum(4,4) - Sum(2,4)*Sum(4,2)
          dE2    = Sum(2,1)*Sum(4,4) - Sum(2,4)*Sum(4,1)
          dE3    = Sum(2,1)*Sum(4,2) - Sum(2,2)*Sum(4,1)
          dD3    = Sum(1,1)*dE1 - Sum(1,2)*dE2 + Sum(1,4)*dE3
          dE1    = Sum(2,2)*Sum(3,3) - Sum(2,3)*Sum(3,2)
          dE2    = Sum(2,1)*Sum(3,3) - Sum(2,3)*Sum(3,1)
          dE3    = Sum(2,1)*Sum(3,2) - Sum(2,2)*Sum(3,1)
          dD4    = Sum(1,1)*dE1 - Sum(1,2)*dE2 + Sum(1,3)*dE3
          dVA(1) = dD1 / dDeter
          dVA(2) = dD2 / dDeter
          dVA(3) = dD3 / dDeter
          dVA(4) = dD4 / dDeter
      endif

C    --- resultats ---

      Correction = 1.
      if ( Unweighted ) then            ! Chaque poids Ws du Khi2 vaut l'unite ou zero
          Correction  = Khi2 / float(NPtsF-NParam)
      endif
      DO IParam = 1,NParam
          A(IParam)   = sngl( dA(IParam) )
          dVA(IParam) = Correction* dVA(IParam)
          SA(IParam)  = sngl(dsqrt(abs( dVA(IParam) )))
      ENDDO

C    ===================================================================
      RETURN
      end

C    ===================================================================
      SubRoutine GammaI (dP,dQ,dGALn,dA,dX)
C    ===================================================================
C     Le sous-programme retourne les valeur de la fonction Gamma incomplete
C     d'argument dA :
C        entre les bornes zero et dX       : dP (normalisee)
C        entre les bornes dX et l'infini   : dQ, a savoir 1-dP
C        le logarithme de la normalisation : dGLn, soit Ln[ Gamma(dA) ]
C
C     Source : Numerical Recipes
C    ===================================================================

      parameter (
     1    NIterM  = 100 )                        ! nombre maximal d'iterations

      real*8
     1    dA,dX,                                 ! arguments
     1    dP,dQ,dGALn,                           ! valeurs en retour
     1    dGammaLn,                              ! Ln de Gamma
     1    dF,                                    ! facteur multiplicatif

     1    dA1,dAN,dB,dC,dD,                      ! variables intermediaires
     1    dTerm,dRes,                            ! termes des developpements
     1    dSmall,dRapp,dEps                      ! precision et convergence

      if ( dA.lt.0.D0 .or. dX.lt.0.D0 ) then
          STOP ' >> Arguments errones pour GammaI <<'
      else
          dA1    = dA + 1.D0
          dEps   = 3.D-7
          dSmall = 1.D-30
      endif
C    -------------------------------------------------------------------
      dGALn = dGammaLn ( dA )
      dF    = dexp( -dX + dA*dlog( dX ) - dGALn )

      if ( dX.lt.dA1 ) then            ! developpement en serie

          dTerm = 1.D0 / dA
          dRes  = dTerm
          dRapp = dabs( dTerm / dRes )
          NIter = 1
          DO WHILE ( dRapp.gt.dEps .AND. NIter.le.NIterM )
              dTerm  = dTerm * dX / ( dA + dfloat(NIter) )
              dRes   = dRes + dTerm
              dRapp  = dabs( dTerm / dRes )
              NIter  = NIter + 1
          ENDDO
          if ( NIter.gt.NIterM ) then
              STOP ' >> Pas de converge sur GammaSer <<'
          else
              dP = dF * dRes
              dQ = 1.D0 - dP
          endif

      else                             ! representation en fraction continue

          dB    = dX + 1.D0 - dA
          dC    = 1.D0 / dSmall
          dD    = 1.D0 / dB
          dRes  = dD
          dRapp = dabs( dC*dD - 1.D0 )
          NIter = 1
          DO WHILE ( dRapp.gt.dEps .AND. NIter.le.NIterM )
              dAN    = -float(NIter) * ( float(NIter) - dA )
              dB     = dB + 2.D0
              dC     = dB + dAN / dC
              if ( dabs(dC).lt.dSmall ) dC = dSmall
              dD     = dB + dAN * dD
              if ( dabs(dD).lt.dSmall ) dD = dSmall
              dD     = 1.D0 / dD
              dTerm  = dC * dD
              dRes   = dRes * dTerm
              dRapp  = dabs( dTerm - 1.D0 ) 
              NIter  = NIter + 1
          ENDDO
          if ( NIter.gt.NIterM ) then
              STOP ' >> Pas de converge sur GammaFra <<'
          else
              dQ = dF * dRes
              dP = 1.D0 - dQ
          endif

      endif
C    ===================================================================
      RETURN
      end

C    ===================================================================
      real*8 FUNCTION dGammaLn (dX)
C    ===================================================================
C     La fonction retourne le logarithme neperien de la fonction Gamma(X)
C     pour X > 0. Le calcul est base sur Gamma(1+X) = X Gamma(X) et sur
C     l'approximation de Lanczos pour Gamma(1+X).
C
C     Source : Numerical Recipes
C    ===================================================================
      real*8
     1    dX,                                    ! argument de la fonction
     1    dX1,dX2,dFLn,                          ! variables intermediaires
     1    ds2Pi,                                 ! racine carre de 2*Pi
     1    dSum,dCoe(6)                           ! constantes de Lanczos

      dSum    =    1.00000000019001  D0          ! dCoe(0)
      dCoe(1) =    76.1800917294715  D0
      dCoe(2) =   -86.5053203294168  D0     
      dCoe(3) =    24.0140982408309  D0
      dCoe(4) =   -1.23173957245015  D0
      dCoe(5) =  0.1208650973866179  D-2
      dCoe(6) = -0.5395239384953     D-5

      ds2Pi   = dsqrt( 2.D0* 4.D0*datan(1.D0) )
C    -------------------------------------------------------------------
      if ( dX.gt.0.D0 ) then

          DO I = 1,6
              dSum = dSum + dCoe(I) / ( dX + dfloat(I) )
          ENDDO

          dX1  = dX + 0.5D0
          dX2  = dX + 5.5D0
          dFLn = dX1 * dlog( dX2 ) - dX2
          dGammaLn = dFLn + dlog( dSum * ds2Pi / dX )

      else
          STOP ' >> Argument errone pour Gamma(X) <<'
      endif

C    ===================================================================
      RETURN
      end



