texlive[51149] Master/texmf-dist: pst-func (17may19)

commits+karl at tug.org commits+karl at tug.org
Fri May 17 22:56:27 CEST 2019


Revision: 51149
          http://tug.org/svn/texlive?view=revision&revision=51149
Author:   karl
Date:     2019-05-17 22:56:26 +0200 (Fri, 17 May 2019)
Log Message:
-----------
pst-func (17may19)

Modified Paths:
--------------
    trunk/Master/texmf-dist/doc/generic/pst-func/Changes
    trunk/Master/texmf-dist/doc/generic/pst-func/pst-func-doc.pdf
    trunk/Master/texmf-dist/tex/generic/pst-func/pst-func.tex
    trunk/Master/texmf-dist/tex/latex/pst-func/pst-func.sty

Modified: trunk/Master/texmf-dist/doc/generic/pst-func/Changes
===================================================================
--- trunk/Master/texmf-dist/doc/generic/pst-func/Changes	2019-05-17 20:56:07 UTC (rev 51148)
+++ trunk/Master/texmf-dist/doc/generic/pst-func/Changes	2019-05-17 20:56:26 UTC (rev 51149)
@@ -1,4 +1,5 @@
 ..... pst-func.tex
+0.93  2019-05-17  - fix for missing end in a local dictionary (\psBinomialX)
 0.92  2018-12-13  - allow algebraic mode for \pscumIntegral
 0.91  2018-11-15  - new algorithm for sin/cos integral to prevent problems
                     with large values 

Modified: trunk/Master/texmf-dist/doc/generic/pst-func/pst-func-doc.pdf
===================================================================
(Binary files differ)

Modified: trunk/Master/texmf-dist/tex/generic/pst-func/pst-func.tex
===================================================================
--- trunk/Master/texmf-dist/tex/generic/pst-func/pst-func.tex	2019-05-17 20:56:07 UTC (rev 51148)
+++ trunk/Master/texmf-dist/tex/generic/pst-func/pst-func.tex	2019-05-17 20:56:26 UTC (rev 51149)
@@ -31,8 +31,8 @@
 % interface to the `xkeyval' package
 \pst at addfams{pst-func}
 %
-\def\fileversion{0.92}
-\def\filedate{2018/12/13}
+\def\fileversion{0.93}
+\def\filedate{2019/05/17}
 \message{`PST-func' v\fileversion, \filedate\space (hv)}
 %
 \pstheader{pst-func.pro}
@@ -581,51 +581,56 @@
     kOld scx 0 moveto   % starting point#
 %%----------------------------------------------------------------------------------------------------------------------------------------------------------------
 %%-------------------- Code, der bei gro{\ss}em N \"{u}ber den Logarithmus arbeitet von Manuel Luque ---------------------------------------------
-                     /SumLog {%                                                                               log(1) + log(2) + ... + log(n)   =  log(n!)
-                                        1 dict begin %                                                         Erwartet die Eingabe eines Wertes, n\"{a}mlich bis zu welchem Wert addiert werden soll ---> n
-                                        /nV exch def %                                                       der \"{u}bergebene Wert wird in nV abgespeichert
-                                        /iV 1 def %                                                               Startwert ist  iV=1
-                                        0 nV { iV log add /iV iV 1 add def } repeat %  0 + log(1) + log(2) + ... + log(n)   Die Null ist dazu n\"{o}tig um die erste Addition machen zu k\"{o}nnen
-                                        end
-                                     } def
-                /binomial_comb{ %                                                                      log(N!) - log(k!) - log((n-k)!)    =  log[N!/(k!*(n-k)!)]
-                                                  2 dict begin
-                                                  /nV exch def
-                                                  /NV exch def
-                                                  NV SumLog nV SumLog sub
-                                                  NV nV sub SumLog sub
-                                                end
-                                              } def
-                /PnN {
-                              3 dict begin
-                              /pV exch def
-                              /nV exch def
-                              /NV exch def
-                              10
-                              NV nV binomial_comb
-                              nV pV log mul
-                              NV nV sub 1 pV sub log mul add add
-                              exp
-                             } def
+    /SumLog {%                                                                               log(1) + log(2) + ... + log(n)   =  log(n!)
+      2 dict begin %                                                         Erwartet die Eingabe eines Wertes, n\"{a}mlich bis zu welchem Wert addiert werden soll ---> n
+      /nV exch def %                                                       der \"{u}bergebene Wert wird in nV abgespeichert
+      /iV 1 def %                                                               Startwert ist  iV=1
+      0 nV { iV log add /iV iV 1 add def } repeat %  0 + log(1) + log(2) + ... + log(n)   Die Null ist dazu n\"{o}tig um die erste Addition machen zu k\"{o}nnen
+      end
+    } def
+    /binomial_comb{ %                                                                      log(N!) - log(k!) - log((n-k)!)    =  log[N!/(k!*(n-k)!)]
+      2 dict begin
+      /nV exch def
+      /NV exch def
+      NV SumLog nV SumLog sub
+      NV nV sub SumLog sub
+      end
+    } def
+    /PnN {
+      3 dict begin
+      /pV exch def
+      /nV exch def
+      /NV exch def
+      10
+      NV nV binomial_comb
+      nV pV log mul
+      NV nV sub 1 pV sub log mul add add
+      exp
+      end
+    } def
 %%------------------------------------------------------------------------------------------------
 %%------------------------------------------------------------------------------------------------
-          N ValueSwitch2Log gt { } {%
-                                     0 1 m 1 sub {%
-                                                              /k exch def       % save loop variable
-                                                              k 0 eq
-                                                              { /Y q N exp def }
-                                                              { /Y Y N k sub 1 add mul k div p mul q div def }
-                                                              ifelse
-                                                           } for
-                                     } ifelse
-                                m 1 n {%            % n-m+1 times
-                                             /k exch def       % save loop variable
-                                             N ValueSwitch2Log gt { N k p PnN /Y exch def }
-                                                               { k 0 eq
-                                                                             { /Y q N exp def }
-                                                                             { /Y Y N k sub 1 add mul k div p mul q div def }
-                                                                             ifelse
-                                                             } ifelse % recursive definition
+    N ValueSwitch2Log gt 
+      { } 
+      { 0 1 m 1 sub 
+        {%
+          /k exch def       % save loop variable
+          k 0 eq
+            { /Y q N exp def }
+            { /Y Y N k sub 1 add mul k div p mul q div def }
+          ifelse
+        } for
+      } ifelse
+      m 1 n {%            % n-m+1 times
+        /k exch def       % save loop variable
+        N ValueSwitch2Log gt 
+          { N k p PnN /Y exch def }
+          { k 0 eq
+            { /Y q N exp def }
+            { /Y Y N k sub 1 add mul k div p mul q div def }
+            ifelse 
+          } 
+          ifelse % recursive definition
       \ifx\psk at fillstylename\pst at alternateColors
         newpath
         kOld scx 0 moveto
@@ -725,7 +730,7 @@
     \else\psBinomialF at iii{#1}{#2}{#3}{#5}\fi
   \fi}%
 \def\psBinomialF at iii#1#2#3#4{%
- \addbefore at par{valuewidth=15}%
+  \addbefore at par{valuewidth=15}%
   \begin at OpenObj
   \addto at pscode{%
     /ValueSwitch2Log \psFunc at Switch2Log\space def
@@ -740,72 +745,75 @@
     \ifPst at markZeros /kOld dx neg m add def \else
     /kOld m def \fi
     \psFunc at leftEnd 0 eq
-    { }
-    { kOld 0 eq
-    { kOld \psFunc at leftEnd sub scx 0 moveto   % starting point
-    \ifPst at LineEnding
-    kOld \psFunc at radiusout\pst at number\psxunit div sub scx 0 L stroke
-     kOld scx 0 newpath \psFunc at radiusout 0 360 arc kOld scx 0 \psFunc at radiusinR 360 0 arcn closepath \pst at usecolor\psk at LineEndColorR fill \else
-    kOld scx 0 L stroke \fi }
-    { } ifelse } ifelse
+      { }
+      { kOld 0 eq
+        { kOld \psFunc at leftEnd sub scx 0 moveto   % starting point
+          \ifPst at LineEnding
+            kOld \psFunc at radiusout\pst at number\psxunit div sub scx 0 L stroke
+            kOld scx 0 newpath \psFunc at radiusout 0 360 arc kOld scx 0 
+            \psFunc at radiusinR 360 0 arcn closepath \pst at usecolor\psk at LineEndColorR fill 
+          \else
+            kOld scx 0 L stroke 
+          \fi 
+        }{ } ifelse } ifelse
     kOld scx 0 moveto   % starting point
 %%----------------------------------------------------------------------------------------------------------------------------------------------------------------
 %%-------------------- Code, der bei gro{\ss}em N \"{u}ber den Logarithmus arbeitet von Manuel Luque ---------------------------------------------
-                     /SumLog {%                                                                               log(1) + log(2) + ... + log(n)   =  log(n!)
-                                        1 dict begin %                                                         Erwartet die Eingabe eines Wertes, n\"{a}mlich bis zu welchem Wert addiert werden soll ---> n
-                                        /nV exch def %                                                       der \"{u}bergebene Wert wird in nV abgespeichert
-                                        /iV 1 def %                                                               Startwert ist  iV=1
-                                        0 nV { iV log add /iV iV 1 add def } repeat %  0 + log(1) + log(2) + ... + log(n)   Die Null ist dazu n\"{o}tig um die erste Addition machen zu k\"{o}nnen
-                                        end
-                                     } def
-                /binomial_comb{ %                                                                      log(N!) - log(k!) - log((n-k)!)    =  log[N!/(k!*(n-k)!)]
-                                                  2 dict begin
-                                                  /nV exch def
-                                                  /NV exch def
-                                                  NV SumLog nV SumLog sub
-                                                  NV nV sub SumLog sub
-                                                end
-                                              } def
-                /PnN {
-                              3 dict begin
-                              /pV exch def
-                              /nV exch def
-                              /NV exch def
-                              10
-                              NV nV binomial_comb
-                              nV pV log mul
-                              NV nV sub 1 pV sub log mul add add
-                              exp
-                             } def
+    /SumLog {%                                                                               log(1) + log(2) + ... + log(n)   =  log(n!)
+      2 dict begin %                                                         Erwartet die Eingabe eines Wertes, n\"{a}mlich bis zu welchem Wert addiert werden soll ---> n
+      /nV exch def %                                                       der \"{u}bergebene Wert wird in nV abgespeichert
+      /iV 1 def %                                                               Startwert ist  iV=1
+      0 nV { iV log add /iV iV 1 add def } repeat %  0 + log(1) + log(2) + ... + log(n)   Die Null ist dazu n\"{o}tig um die erste Addition machen zu k\"{o}nnen
+      end
+    } def
+    /binomial_comb{ %                                                                      log(N!) - log(k!) - log((n-k)!)    =  log[N!/(k!*(n-k)!)]
+      2 dict begin
+      /nV exch def
+      /NV exch def
+      NV SumLog nV SumLog sub
+      NV nV sub SumLog sub
+      end
+    } def
+    /PnN {
+      3 dict begin
+      /pV exch def
+      /nV exch def
+      /NV exch def
+      10
+      NV nV binomial_comb
+      nV pV log mul
+      NV nV sub 1 pV sub log mul add add
+      exp
+      end
+    } def
 %%------------------------------------------------------------------------------------------------
 %%------------------------------------------------------------------------------------------------
-                               0 1 m 1 sub {
-                                                        /k exch def       % save loop variable
-                                                       N ValueSwitch2Log gt {  k 0 eq
-                                                                                     { N k p PnN /Y exch def /F Y def }
-                                                                                     { N k p PnN /Y exch def /F F Y add def }
-                                                                          ifelse }
-                                                                     { k 0 eq
-                                                                     { /Y q N exp def
-                                                                      /F Y def }
-                                                                     { /Y Y N k sub 1 add mul k div p mul q div def
-                                                                      /F F Y add def
-                                                                      } ifelse
-                                                                   } ifelse
-                                                   } for
-        m 1 n {             % n-m+1 times
-                     /k exch def       % save loop variable
-                     N ValueSwitch2Log gt { k 0 eq
-                                                    { N k p PnN /Y exch def /F Y def }
-                                                    { N k p PnN /Y exch def /F F Y add def } ifelse }
-                     {  k 0 eq
-                                     { /Y q N exp def
-                                      /F Y def }
-                                     { /Y Y N k sub 1 add mul k div p mul q div def
-                                     /F F Y add def
-                                     } ifelse
-                      } ifelse  % recursive definition
-                      F 1 gt { /F 1 def } if
+    0 1 m 1 sub {
+      /k exch def       % save loop variable
+      N ValueSwitch2Log gt {  k 0 eq
+        { N k p PnN /Y exch def /F Y def }
+        { N k p PnN /Y exch def /F F Y add def }
+        ifelse 
+      }{ k 0 eq
+         { /Y q N exp def /F Y def }
+         { /Y Y N k sub 1 add mul k div p mul q div def
+           /F F Y add def
+         } ifelse
+       } ifelse
+     } for
+    m 1 n {             % n-m+1 times
+      /k exch def       % save loop variable
+      N ValueSwitch2Log gt 
+        { k 0 eq
+          { N k p PnN /Y exch def /F Y def }
+          { N k p PnN /Y exch def /F F Y add def } 
+        ifelse }
+        {  k 0 eq
+          { /Y q N exp def /F Y def }
+          { /Y Y N k sub 1 add mul k div p mul q div def /F F Y add def
+        } ifelse
+      } ifelse  % recursive definition
+      F 1 gt { /F 1 def } if
       \ifPst at markZeros kOld scx F scy L k dx add scx F scy L k dx add scx 0 L kOld 1 add scx 0 L
       \else
        kOld scx F scy newpath \psFunc at radiusout 0 360 arc kOld scx F scy \psFunc at radiusinL 360 0 arcn closepath \pst at usecolor\psk at LineEndColorL fill
@@ -875,60 +883,58 @@
     kOld scx 0 moveto   % starting point
 %%----------------------------------------------------------------------------------------------------------------------------------------------------------------
 %%-------------------- Code, der bei gro{\ss}em N \"{u}ber den Logarithmus arbeitet von Manuel Luque ---------------------------------------------
-                     /SumLog {%                                                                               log(1) + log(2) + ... + log(n)   =  log(n!)
-                                        1 dict begin %                                                         Erwartet die Eingabe eines Wertes, n\"{a}mlich bis zu welchem Wert addiert werden soll ---> n
-                                        /nV exch def %                                                       der \"{u}bergebene Wert wird in nV abgespeichert
-                                        /iV 1 def %                                                               Startwert ist  iV=1
-                                        0 nV { iV log add /iV iV 1 add def } repeat %  0 + log(1) + log(2) + ... + log(n)   Die Null ist dazu n\"{o}tig um die erste Addition machen zu k\"{o}nnen
-                                        end
-                                     } def
-                /binomial_comb{ %                                                                      log(N!) - log(k!) - log((n-k)!)    =  log[N!/(k!*(n-k)!)]
-                                                  2 dict begin
-                                                  /nV exch def
-                                                  /NV exch def
-                                                  NV SumLog nV SumLog sub
-                                                  NV nV sub SumLog sub
-                                                end
-                                              } def
-                /PnN {
-                              3 dict begin
-                              /pV exch def
-                              /nV exch def
-                              /NV exch def
-                              10
-                              NV nV binomial_comb
-                              nV pV log mul
-                              NV nV sub 1 pV sub log mul add add
-                              exp
-                             } def
+    /SumLog {%                                                                               log(1) + log(2) + ... + log(n)   =  log(n!)
+      2 dict begin %                                                         Erwartet die Eingabe eines Wertes, n\"{a}mlich bis zu welchem Wert addiert werden soll ---> n
+      /nV exch def %                                                       der \"{u}bergebene Wert wird in nV abgespeichert
+      /iV 1 def %                                                               Startwert ist  iV=1
+      0 nV { iV log add /iV iV 1 add def } repeat %  0 + log(1) + log(2) + ... + log(n)   Die Null ist dazu n\"{o}tig um die erste Addition machen zu k\"{o}nnen
+      end
+    } def
+    /binomial_comb{ %                                                                      log(N!) - log(k!) - log((n-k)!)    =  log[N!/(k!*(n-k)!)]
+      2 dict begin
+      /nV exch def
+      /NV exch def
+      NV SumLog nV SumLog sub
+      NV nV sub SumLog sub
+      end
+    } def
+    /PnN {
+      3 dict begin
+      /pV exch def
+      /nV exch def
+      /NV exch def
+      10
+      NV nV binomial_comb
+      nV pV log mul
+      NV nV sub 1 pV sub log mul add add
+      exp
+      end
+    } def
 %%------------------------------------------------------------------------------------------------
-%%------------------------------------------------------------------------------------------------
-                               0 1 m 1 sub {
-                                                        /k exch def       % save loop variable
-                                                       N ValueSwitch2Log gt {  k 0 eq
-                                                                                     { N k p PnN /Y exch def /F Y def /FS 1 F sub def }
-                                                                                     { N k p PnN /Y exch def /F F Y add def /FS 1 F sub def }
-                                                                          ifelse }
-                                                                     { k 0 eq
-                                                                     { /Y q N exp def
-                                                                      /F Y def /FS 1 F sub def }
-                                                                     { /Y Y N k sub 1 add mul k div p mul q div def
-                                                                      /F F Y add def /FS 1 F sub def }
-                                                                   ifelse } ifelse
-                                                   } for
-        m 1 n {             % n-m+1 times
-                     /k exch def       % save loop variable
-                     N ValueSwitch2Log gt { k 0 eq
-                                                    { N k p PnN /Y exch def /F Y def /FS 1 F sub def }
-                                                    { N k p PnN /Y exch def /F F Y add def /FS 1 F sub def } ifelse }
-                     {  k 0 eq
-                                     { /Y q N exp def
-                                      /F Y def /FS 1 F sub def }
-                                     { /Y Y N k sub 1 add mul k div p mul q div def
-                                     /F F Y add def /FS 1 F sub def }
-                                  ifelse
-                      } ifelse  % recursive definition
-                       FS 0 lt { /FS 0 def } if
+    0 1 m 1 sub {
+     /k exch def       % save loop variable
+     N ValueSwitch2Log gt {  k 0 eq
+       { N k p PnN /Y exch def /F Y def /FS 1 F sub def }
+       { N k p PnN /Y exch def /F F Y add def /FS 1 F sub def }
+      ifelse }
+         { k 0 eq
+           { /Y q N exp def /F Y def /FS 1 F sub def }
+           { /Y Y N k sub 1 add mul k div p mul q div def
+             /F F Y add def /FS 1 F sub def }
+         ifelse } ifelse
+      } for
+      m 1 n {             % n-m+1 times
+        /k exch def       % save loop variable
+        N ValueSwitch2Log gt { k 0 eq
+          { N k p PnN /Y exch def /F Y def /FS 1 F sub def }
+          { N k p PnN /Y exch def /F F Y add def /FS 1 F sub def } ifelse }
+        {  k 0 eq
+          { /Y q N exp def  /F Y def /FS 1 F sub def }
+          { /Y Y N k sub 1 add mul k div p mul q div def
+            /F F Y add def /FS 1 F sub def }
+        ifelse
+      } ifelse  % recursive definition
+      FS 0 lt { /FS 0 def } if
       \ifPst at markZeros kOld scx FS scy L k dx add scx FS scy L k dx add scx 0 L kOld 1 add scx 0 L
       \else
       \ifPst at LineEnding
@@ -1033,6 +1039,7 @@
                               nV pV log mul
                               NV nV sub 1 pV sub log mul add add
                               exp
+       end
                              } def
 %%------------------------------------------------------------------------------------------------
 %%------------------------------------------------------------------------------------------------

Modified: trunk/Master/texmf-dist/tex/latex/pst-func/pst-func.sty
===================================================================
--- trunk/Master/texmf-dist/tex/latex/pst-func/pst-func.sty	2019-05-17 20:56:07 UTC (rev 51148)
+++ trunk/Master/texmf-dist/tex/latex/pst-func/pst-func.sty	2019-05-17 20:56:26 UTC (rev 51149)
@@ -13,4 +13,4 @@
   \ProvidesFile{pst-func.pro}[2018/12/13 v. 0.17,  PostScript prologue file (hv)]
 \@addtofilelist{pst-func.pro}}{}%
 \endinput
-%% $Id: pst-func.sty 861 2018-12-13 20:40:06Z herbert $
+%% $Id: pst-func.sty 887 2018-12-29 13:17:59Z herbert $



More information about the tex-live-commits mailing list