/[lohnrechner]/trunk/LST2008.py
ViewVC logotype

Diff of /trunk/LST2008.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

LST2005.py revision 37 by wilde, Wed Jul 20 14:18:07 2005 UTC trunk/LST2008.py revision 77 by frank, Tue Jan 29 19:00:16 2008 UTC
# Line 1  Line 1 
1  # -*- coding: iso-8859-1 -*-  # -*- coding: iso-8859-1 -*-
2  # --------------------------------------------------------------------  # --------------------------------------------------------------------
3  # LST2005 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2005  # LST2008 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2008
4  # $Id$  # $Id$
5  # --------------------------------------------------------------------  # --------------------------------------------------------------------
6  #  #
7  # Copyright (c) 2005 by Intevation GmbH  # Copyright (c) 2005, 2006, 2007, 2008 by Intevation GmbH
8  # Authors:  # Authors:
9  # Sascha Wilde <[email protected]>  # Sascha Wilde <[email protected]>
10  #  #
# Line 14  Line 14 
14  """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan  """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan
15     wie im offiziellen Programmablaufplan des Bundesfinanzministerium     wie im offiziellen Programmablaufplan des Bundesfinanzministerium
16     dokumentiert.     dokumentiert.
17     http://www.bundesfinanzministerium.de/Service/Interaktiver-Steuerrechner-.577.htm"""     https://www.abgabenrechner.de/pruefdaten/pap2008.pdf"""
18    
19  __version__ = "$Revision$"  __version__ = "$Revision$"
20  # $Source$  # $Source:$
21    
22  def _ModulVersion():  def _ModulVersion():
23      return __version__[11:-2]      return __version__[11:-2]
# Line 51  VI  = 6 Line 51  VI  = 6
51    
52  class LST:  class LST:
53      def __init__(self,      def __init__(self,
54                   RE4=0,                   AJAHR   =1964,
55                   ALTER1=0,                   ALTER1  =0,
56                   HINZUR=0,                   JFREIB  =0,
57                   JFREIB=0,                   JHINZU  =0,
58                   JHINZU=0,                   JRE4    =0,
59                   JRE4  =0,                   JVBEZ   =0,
60                   JVBEZ =0,                   KRV     =0,
61                   KRV   =0,                   LZZ     =2,
62                   LZZ   =2,                   LZZFREIB=0,
63                   R     =0,                   LZZHINZU=0,
64                   SONSTB=0,                   R       =0,
65                   STKL  =1,                   RE4     =0,
66                   VBEZ  =0,                   SONSTB  =0,
67                   VBEZM =0,                   STERBE  =0,
68                   VBEZS =0,                   STKL    =1,
69                   VBS   =0,                   VBEZ    =0,
70                   VMT   =0,                   VBEZM   =0,
71                   WFUNDF=0,                   VBEZS   =0,
72                   ZKF   =0,                   VBS     =0,
73                   ZMVB  =0):                   VJAHR   =0,
74          self.Set_RE4(RE4)                   VKAPA   =0,
75                     VMT     =0,
76                     ZKF     =0,
77                     ZMVB    =0):
78            self.Set_AJAHR(AJAHR)
79          self.Set_ALTER1(ALTER1)          self.Set_ALTER1(ALTER1)
         self.Set_HINZUR(HINZUR)  
80          self.Set_JFREIB(JFREIB)          self.Set_JFREIB(JFREIB)
81          self.Set_JHINZU(JHINZU)          self.Set_JHINZU(JHINZU)
82          self.Set_JRE4(JRE4)          self.Set_JRE4(JRE4)
83          self.Set_JVBEZ(JVBEZ)          self.Set_JVBEZ(JVBEZ)
84          self.Set_KRV(KRV)          self.Set_KRV(KRV)
85          self.Set_LZZ(LZZ)          self.Set_LZZ(LZZ)
86            self.Set_LZZFREIB(LZZFREIB)
87            self.Set_LZZHINZU(LZZHINZU)
88          self.Set_R(R)          self.Set_R(R)
89            self.Set_RE4(RE4)
90          self.Set_SONSTB(SONSTB)          self.Set_SONSTB(SONSTB)
91            self.Set_STERBE(STERBE)
92          self.Set_STKL(STKL)          self.Set_STKL(STKL)
93          self.Set_VBEZ(VBEZ)          self.Set_VBEZ(VBEZ)
94          self.Set_VBEZM(VBEZM)          self.Set_VBEZM(VBEZM)
95          self.Set_VBEZS(VBEZS)          self.Set_VBEZS(VBEZS)
96          self.Set_VBS(VBS)          self.Set_VBS(VBS)
97            self.Set_VJAHR(VJAHR)
98            self.Set_VKAPA(VKAPA)
99          self.Set_VMT(VMT)          self.Set_VMT(VMT)
         self.Set_WFUNDF(WFUNDF)  
100          self.Set_ZKF(ZKF)          self.Set_ZKF(ZKF)
101          self.Set_ZMVB(ZMVB)          self.Set_ZMVB(ZMVB)
102          # Vorgegebene Ausgangsparameter          # Vorgegebene Ausgangsparameter
# Line 108  class LST: Line 116  class LST:
116          # Interne Felder          # Interne Felder
117          # Laut Dokumentation sollen diese vor der Berechnung gel�scht werden,          # Laut Dokumentation sollen diese vor der Berechnung gel�scht werden,
118          # es ist mir nicht klar, ob das wirklich n�tig ist...          # es ist mir nicht klar, ob das wirklich n�tig ist...
119          self._ALTE = 0          self._ALTE = 0.0        # 2 Dezimalstellen
120          self._ANP = 0          self._ANP = 0
121          self._ANTEIL1 = 0          self._ANTEIL1 = 0
122          self._ANTEIL2 = 0          self._ANTEIL2 = 0
123          self._BMG = 0          self._BMG = 0.0         # 2 Dezimalstellen
124          self._DIFF = 0          self._DIFF = 0
125          self._EFA = 0          self._EFA = 0
126          self._FVB = 0          self._FVB = 0.0         # 2 Dezimalstellen
127            self._FVBSO = 0.0       # 2 Dezimalstellen
128          self._FVBZ = 0          self._FVBZ = 0
129            self._FVBZSO = 0
130            self._FVBZOSO = 0
131            self._HBALTE = 0
132            self._HFVB = 0
133            self._HFVBZ = 0.0       # 2 Dezimalstellen
134            self._HFVBZSO = 0.0     # 2 Dezimalstellen
135            self._J = 0
136          self._JBMG = 0          self._JBMG = 0
137            self._JLFREIB = 0.0     # 2 Dezimalstellen
138            self._JLHINZU = 0.0     # 2 Dezimalstellen
139          self._JW = 0          self._JW = 0
140          self._KENNZ = 0          self._K = 0
141            self._KENNVMT = 0
142          self._KFB = 0          self._KFB = 0
143          self._KZTAB = 1          self._KZTAB = 1
144          self._LSTJAHR = 0          self._LSTJAHR = 0
145          self._LST1 = 0          self._LST1 = 0
146          self._LST2 = 0          self._LST2 = 0
147          self._LST3 = 0          self._LST3 = 0
148            self._LSTOSO = 0
149            self._LSTSO = 0
150          self._MIST = 0          self._MIST = 0
         self._RE4LZZ = 0  
         self._RE4LZZV = 0  
151          self._RW = 0.0          self._RW = 0.0
152          self._SAP = 0          self._SAP = 0
153          self._SOLZFREI = 0          self._SOLZFREI = 0
154          self._SOLZJ = 0.0  # 2 Dezimalstellen          self._SOLZJ = 0.0       # 2 Dezimalstellen
155          self._SOLZMIN = 0.0  # 2 Dezimalstellen          self._SOLZMIN = 0.0     # 2 Dezimalstellen
156          self._ST = 0          self._ST = 0
157          self._ST1 = 0          self._ST1 = 0
158          self._ST2 = 0          self._ST2 = 0
159            self._TAB1=(None,  # 1 als erstes Element, wie im PAP
160                        0.400, # bis 2005
161                        0.384, # 2006
162                        0.368, # 2007
163                        0.352, # 2008
164                        0.336, # 2009
165                        0.320, # 2010
166                        0.304, # 2011
167                        0.288, # 2012
168                        0.272, # 2013
169                        0.256, # 2014
170                        0.240, # 2015
171                        0.224, # 2016
172                        0.208, # 2017
173                        0.192, # 2018
174                        0.176, # 2019
175                        0.160, # 2020
176                        0.152, # 2021
177                        0.144, # 2022
178                        0.136, # 2023
179                        0.128, # 2024
180                        0.120, # 2025
181                        0.112, # 2026
182                        0.104, # 2027
183                        0.096, # 2028
184                        0.088, # 2029
185                        0.080, # 2030
186                        0.072, # 2031
187                        0.064, # 2032
188                        0.056, # 2033
189                        0.048, # 2034
190                        0.040, # 2035
191                        0.032, # 2036
192                        0.024, # 2037
193                        0.016, # 2038
194                        0.008, # 2039
195                        0.000) # 2040
196            self._TAB2=(None,  # 1 als erstes Element, wie im PAP
197                        3000,  # bis 2005
198                        2880,  # 2006
199                        2760,  # 2007
200                        2640,  # 2008
201                        2520,  # 2009
202                        2400,  # 2010
203                        2280,  # 2011
204                        2160,  # 2012
205                        2040,  # 2013
206                        1920,  # 2014
207                        1800,  # 2015
208                        1680,  # 2016
209                        1560,  # 2017
210                        1440,  # 2018
211                        1320,  # 2019
212                        1200,  # 2020
213                        1140,  # 2021
214                        1080,  # 2022
215                        1020,  # 2023
216                         960,  # 2024
217                         900,  # 2025
218                         840,  # 2026
219                         780,  # 2027
220                         720,  # 2028
221                         660,  # 2029
222                         600,  # 2030
223                         540,  # 2031
224                         480,  # 2032
225                         420,  # 2033
226                         360,  # 2034
227                         300,  # 2035
228                         240,  # 2036
229                         180,  # 2037
230                         120,  # 2038
231                          60,  # 2039
232                           0)  # 2040
233            self._TAB3=(None,  # 1 als erstes Element, wie im PAP
234                         900,  # bis 2005
235                         864,  # 2006
236                         828,  # 2007
237                         792,  # 2008
238                         756,  # 2009
239                         720,  # 2010
240                         684,  # 2011
241                         648,  # 2012
242                         612,  # 2013
243                         576,  # 2014
244                         540,  # 2015
245                         504,  # 2016
246                         468,  # 2017
247                         432,  # 2018
248                         396,  # 2019
249                         360,  # 2020
250                         342,  # 2021
251                         324,  # 2022
252                         306,  # 2023
253                         288,  # 2024
254                         270,  # 2025
255                         252,  # 2026
256                         234,  # 2027
257                         216,  # 2028
258                         198,  # 2029
259                         180,  # 2030
260                         162,  # 2031
261                         144,  # 2032
262                         126,  # 2033
263                         108,  # 2034
264                          90,  # 2035
265                          72,  # 2036
266                          54,  # 2037
267                          36,  # 2038
268                          18,  # 2039
269                           0)  # 2040
270            self._TAB4=self._TAB1
271            self._TAB5=(None,  # 1 als erstes Element, wie im PAP
272                        1900,  # bis 2005
273                        1824,  # 2006
274                        1748,  # 2007
275                        1672,  # 2008
276                        1596,  # 2009
277                        1520,  # 2010
278                        1444,  # 2011
279                        1368,  # 2012
280                        1292,  # 2013
281                        1216,  # 2014
282                        1140,  # 2015
283                        1064,  # 2016
284                         988,  # 2017
285                         912,  # 2018
286                         836,  # 2019
287                         760,  # 2020
288                         722,  # 2021
289                         684,  # 2022
290                         646,  # 2023
291                         608,  # 2024
292                         570,  # 2025
293                         532,  # 2026
294                         494,  # 2027
295                         456,  # 2028
296                         418,  # 2029
297                         380,  # 2030
298                         342,  # 2031
299                         304,  # 2032
300                         266,  # 2033
301                         228,  # 2034
302                         190,  # 2035
303                         152,  # 2036
304                         114,  # 2037
305                          76,  # 2038
306                          38,  # 2039
307                           0)  # 2040
308          self._VBEZB = 0          self._VBEZB = 0
309            self._VBEZBSO = 0
310          self._VHB = 0          self._VHB = 0
311          self._VSP = 0.0  # 2 Dezimalstellen          self._VSP = 0.0         # 2 Dezimalstellen
312          self._VSPN = 0          self._VSPN = 0
313          self._VSP1 = 0.0  # 2 Dezimalstellen          self._VSP1 = 0.0        # 2 Dezimalstellen
314          self._VSP2 = 0.0  # 2 Dezimalstellen          self._VSP2 = 0.0        # 2 Dezimalstellen
315          self._VSPKURZ = 0          self._VSPKURZ = 0
316          self._VSPMAX1 = 0          self._VSPMAX1 = 0
317          self._VSPMAX2 = 0          self._VSPMAX2 = 0
318          self._VSPO = 0.0  # 2 Dezimalstellen          self._VSPO = 0.0        # 2 Dezimalstellen
319          self._VSPREST = 0.0  # 2 Dezimalstellen          self._VSPREST = 0.0     # 2 Dezimalstellen
320          self._VSPVOR = 0.0  # 2 Dezimalstellen          self._VSPVOR = 0.0      # 2 Dezimalstellen
321          self._X = 0.0  # 2 Dezimalstellen          self._X = 0.0           # 2 Dezimalstellen
322          self._Y = 0.0  # 6 Dezimalstellen          self._Y = 0.0           # 6 Dezimalstellen
323          self._ZRE4 = 0.0  # 2 Dezimalstellen          self._ZRE4 = 0.0        # 2 Dezimalstellen
324          self._ZRE4VP = 0.0  # 2 Dezimalstellen          self._ZRE4J = 0.0       # 2 Dezimalstellen
325          self._ZRE4VP1 = 0.0  # 2 Dezimalstellen          self._ZRE4OSO = 0.0     # 2 Dezimalstellen
326          self._ZTABFB = 0          self._ZRE4VMT = 0.0     # 2 Dezimalstellen
327          self._ZVE = 0          self._ZRE4VP = 0.0      # 2 Dezimalstellen
328            self._ZTABFB = 0.0      # 2 Dezimalstellen
329            self._ZTABFBOSO = 0.0   # 2 Dezimalstellen
330            self._ZVBEZ = 0.0       # 2 Dezimalstellen
331            self._ZVBEZJ = 0.0      # 2 Dezimalstellen
332            self._ZVE = 0.0         # 2 Dezimalstellen
333          self._ZX = 0          self._ZX = 0
334          self._ZZX = 0          self._ZZX = 0
335          self._HOCH = 0          self._HOCH = 0
336          self._VERGL = 0          self._VERGL = 0
337          # ------------------------------------------------------------          # ------------------------------------------------------------
338          # Anfang der Berechnung          # Anfang der Berechnung
339          self._MRE4LZZ()          self._MRE4JL()
         self._RE4LZZ = self.RE4 - self._FVB \  
                         - self._ALTE - self.WFUNDF \  
                         + self.HINZUR  
         self._RE4LZZV = self.RE4 - self._FVB - self._ALTE  
340          self._MRE4()          self._MRE4()
341            self._MRE4ABZ()
342          self._MZTABFB()          self._MZTABFB()
343            self._KENNVMT = 0
344          self._MLSTJAHR()          self._MLSTJAHR()
345          self._LSTJAHR = self._ST          self._LSTJAHR = self._ST
346          self._JW = self._LSTJAHR * 100          self._JW = self._LSTJAHR * 100
# Line 183  class LST: Line 355  class LST:
355          self._MSOLZ()          self._MSOLZ()
356          self._MSONST()          self._MSONST()
357          self._MVMT()          self._MVMT()
358            
359      # Benutzte Unterprogramme:      # Benutzte Unterprogramme:
360      def _MRE4LZZ(self):      def _MRE4JL(self):
361          if self.VBEZ == 0:          if self.LZZ == 1:
362                self._ZRE4J = self.RE4 / 100
363                self._ZVBEZJ = self.VBEZ / 100
364                self._JLFREIB = self.LZZFREIB / 100
365                self._JLHINZU = self.LZZHINZU / 100
366            elif self.LZZ == 2:
367                self._ZRE4J = self.RE4 * 12 / 100
368                self._ZVBEZJ = self.VBEZ * 12 / 100
369                self._JLFREIB = self.LZZFREIB * 12 / 100
370                self._JLHINZU = self.LZZHINZU * 12 / 100
371            elif self.LZZ == 3:
372                self._ZRE4J = self.RE4 * 360 / 7 / 100
373                self._ZVBEZJ = self.VBEZ * 360 / 7 / 100
374                self._JLFREIB = self.LZZFREIB * 360 / 7 / 100
375                self._JLHINZU = self.LZZHINZU * 360 / 7 / 100
376            else:
377                self._ZRE4J = self.RE4 * 360 / 100
378                self._ZVBEZJ = self.VBEZ * 360 / 100
379                self._JLFREIB = self.LZZFREIB * 360 / 100
380                self._JLHINZU = self.LZZHINZU * 360 / 100
381    
382        def _MRE4(self):
383            if (self._ZVBEZJ == 0):
384              self._FVBZ = 0              self._FVBZ = 0
385              self._FVB = 0              self._FVB = 0
386                self._FVBZSO = 0
387                self._FVBSO = 0
388          else:          else:
389                if self.VJAHR < 2006:
390                    self._J = 1
391                elif self.VJAHR < 2040:
392                    self._J = self.VJAHR - 2004
393                else:
394                    self._J = 36
395              if self.LZZ == 1:              if self.LZZ == 1:
396                  self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS                  self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
397                  self._FVBZ = 75 * self.ZMVB                  self._HFVB = self._TAB2[self._J] / 12 * self.ZMVB
398                    self._FVBZ = ceil(self._TAB3[self._J] / 12 * self.ZMVB)
399              else:              else:
400                  self._VBEZB = self.VBEZM * 12 + self.VBEZS                  self._VBEZB = self.VBEZM * 12 + self.VBEZS
401                  self._FVBZ = 900                  self._HFVB = self._TAB2[self._J]
402              self._FVB = ceil(self._VBEZB * 0.4)                  self._FVBZ = self._TAB3[self._J]
403              if self._FVB > 300000:              self._FVB = self._VBEZB * self._TAB1[self._J] / 100
404                  self._FVB = 300000              if self._FVB > self._HFVB:
405              self._JW = self._FVB                  self._FVB = self._HFVB
406              self._UPANTEIL()              self._VBEZBSO = self.STERBE + self.VKAPA
407              self._FVB = self._ANTEIL2              self._FVBSO = FixedPointCeil(self._FVB + self._VBEZBSO
408                                             * self._TAB1[self._J] / 100)
409                if self._FVBSO > self._TAB2[self._J]:
410                    self._FVBSO = self._TAB2[self._J]
411                self._HFVBZSO = (self._VBEZB + self._VBEZBSO) / 100 - self._FVBSO
412                if self._TAB3[self._J] > self._HFVBZSO:
413                    self._FVBSO = ceil(self._HFVBZSO)
414                else:
415                    self._FVBSO = self._TAB3[self._J]
416                self._HFVBZ = self._VBEZB / 100 - self._FVB
417                if self._FVBZ > self._HFVBZ:
418                    self._FVBZ = ceil(self._HFVBZ)
419            self._MRE4ALTE()
420    
421        def _MRE4ALTE(self):
422          if self.ALTER1 == 0:          if self.ALTER1 == 0:
423              self._ALTE = 0              self._ALTE = 0
424          else:          else:
425              self._BMG = self.RE4 - self.VBEZ              if self.AJAHR < 2006:
426              self._ALTE = ceil(self._BMG * 0.4)                  self._K = 1
427              self._JW = 190000              elif self.AJAHR < 2040:
428              self._UPANTEIL()                  self._K = self.AJAHR - 2004
429              if self._ALTE > self._ANTEIL2:              else:
430                  self._ALTE = self._ANTEIL2                  self._K = 36
431                self._BMG = self._ZRE4J - self._ZVBEZJ
432                self._ALTE = FixedPointCeil(self._BMG * self._TAB4[self._K])
433                self._HBALTE = self._TAB5[self._K]
434                if self._ALTE > self._HBALTE:
435                    self._ALTE = self._HBALTE
436    
437      def _MRE4(self):      def _MRE4ABZ(self):
438          if self.LZZ == 1:          self._ZRE4 = self._ZRE4J - self._FVB - self._ALTE - self._JLFREIB + self._JLHINZU
             self._ZRE4 = FixedPointFloor(self._RE4LZZ / 100.0)  
             self._ZRE4VP = FixedPointFloor(self._RE4LZZV / 100.0)  
         elif self.LZZ == 2:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.67) * 0.12)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.67) * 0.12)  
         elif self.LZZ == 3:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.89) * 3.6 / 7)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.89) * 3.6 / 7)  
         else:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.56) * 3.6)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.56) * 3.6)  
439          if self._ZRE4 < 0:          if self._ZRE4 < 0:
440              self._ZRE4 = 0.0              self._ZRE4 = 0
441            self._ZRE4VP = self._ZRE4J - self._FVB - self._ALTE
442            if self._ZRE4VP < 0:
443                self._ZRE4VP = 0;
444            self._ZVBEZ = self._ZVBEZJ - self._FVB
445            if self._ZVBEZ < 0:
446                self._ZVBEZ = 0
447    
448      def _MZTABFB(self):      def _MZTABFB(self):
449          self._KZTAB = 1          self._ANP = 0
450          if self.STKL < 6:          if (self._ZVBEZ >= 0) and (self._ZVBEZ < self._FVBZ):
451              if self.VBEZ > 0:              self._FVBZ = self._ZVBEZ
452                  self._ANP = 102          if (self.STKL < 6):
453              if self.RE4 > self.VBEZ:              if (self._ZVBEZ > 0):
454                  self._ANP += 920                  if (self._ZVBEZ - self._FVBZ) < 102:
455                        self._ANP = self._ZVBEZ - self._FVBZ
456                    else:
457                        self._ANP = 102
458          else:          else:
459              self._ANP = 0                          self._FVBZ = 0
460                self._FVBZSO = 0
461            if (self.STKL < 6) and (self._ZRE4 > self._ZVBEZ):
462                if (self._ZRE4 - self._ZVBEZ) < 920:
463                    self._ANP += self._ZRE4 - self._ZVBEZ
464                else:
465                    self._ANP += 920
466            self._KZTAB = 1
467          if self.STKL == 1:          if self.STKL == 1:
468              self._SAP = 36              self._SAP = 36
469              self._KFB = self.ZKF * 5808              self._KFB = self.ZKF * 5808
# Line 254  class LST: Line 481  class LST:
481          else:          else:
482              self._KFB = 0              self._KFB = 0
483          self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ          self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ
         self._KENNZ = 0  
484    
485      def _MLSTJAHR(self):      def _MLSTJAHR(self):
486          if self.STKL < 5:          if self.STKL < 5:
487              self._UPEVP()              self._UPEVP()
488          else:          else:
489              self._VSP = 0.0                self._VSP = 0.0
490          self._ZVE = self._ZRE4 - self._ZTABFB - self._VSP          if self._KENNVMT == 0:
491                self._ZVE = self._ZRE4 - self._ZTABFB - self._VSP
492            elif self._KENNVMT == 1:
493                self._ZVE = self._ZRE4OSO - self._ZTABFBOSO + self._ZRE4VMT - self._VSP
494            else:
495                self._ZVE = (self._ZRE4 - self._ZTABFB) / 5 - self._VSP
496          if self._ZVE < 1:          if self._ZVE < 1:
497              self._ZVE = self._X = 0.0              self._ZVE = self._X = 0.0
498          else:          else:
499              self._X = floor(float(self._ZVE) / self._KZTAB)              self._X = floor(float(self._ZVE) / self._KZTAB)
500          if self.STKL < 5:          if self.STKL < 5:
501              self._UPTAB05()              self._UPTAB07()
502          else:          else:
503              self._MST5_6()              self._MST5_6()
504    
505      def _UPEVP(self):      def _UPEVP(self):
506          if self.KRV == 1:          if self.KRV > 0:
507              self._VSP1 = 1.0              self._VSP1 = 0.0
508          else:          else:
509              if self._ZRE4VP > 62400:              if self._ZRE4VP > 63600:
510                  self._ZRE4VP = 62400                  self._ZRE4VP = 63600
511              self._VSP1 = 0.2 * self._ZRE4VP              self._VSP1 = FixedPointFloor(0.32 * self._ZRE4VP)
512              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0975)              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0995)
513          self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)          self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)
514          self._VHB = 1500 * self._KZTAB          self._VHB = 1500 * self._KZTAB
515          if self._VSP2 > self._VHB:          if self._VSP2 > self._VHB:
# Line 298  class LST: Line 529  class LST:
529              if self._VSPO > self._VSPKURZ:              if self._VSPO > self._VSPKURZ:
530                  self._VSP = self._VSPKURZ                  self._VSP = self._VSPKURZ
531              else:              else:
532                  self._VSP = ceil(self._VSPO)                  self._VSP = floor(self._VSPO)
533          else:          else:
534              self._UMVSP()              self._UMVSP()
535    
536      def _UMVSP(self):      def _UMVSP(self):
537          if self._KENNZ == 1:          self._VSPVOR -= self._ZRE4VP * 0.16
             self._VSPVOR = self._VSPVOR - self._ZRE4VP1 * 0.16  
         else:  
             self._VSPVOR = self._VSPVOR - self._ZRE4VP * 0.16  
538          if self._VSPVOR < 0:          if self._VSPVOR < 0:
539              self._VSPVOR = 0.0              self._VSPVOR = 0.0
540          if self._VSPO > self._VSPVOR:          if self._VSPO > self._VSPVOR:
# Line 316  class LST: Line 544  class LST:
544                  self._VSP += self._VSPMAX1                  self._VSP += self._VSPMAX1
545                  self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)                  self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)
546                  if self._VSPREST > self._VSPMAX2:                  if self._VSPREST > self._VSPMAX2:
547                      self._VSP = ceil(self._VSP + self._VSPMAX2)                      self._VSP = floor(self._VSP + self._VSPMAX2)
548                  else:                  else:
549                      self._VSP = ceil(self._VSP + self._VSPREST)                      self._VSP = floor(self._VSP + self._VSPREST)
550              else:              else:
551                  self._VSP = ceil(self._VSP + self._VSPREST)                  self._VSP = floor(self._VSP + self._VSPREST)
552          else:          else:
553              self._VSP = ceil(self._VSPO)              self._VSP = floor(self._VSPO)
554    
555      def _MST5_6(self):      def _MST5_6(self):
556          self._ZZX = self._X          self._ZZX = self._X
557          if self._ZZX > 25812:          if self._ZZX > 25812:
558              self._ZX = 25812              self._ZX = 25812
559              self._UP5_6()              self._UP5_6()
560              self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)              if self._ZZX > 200000:
561                    self._ST += (200000 - 25812) * 0.42
562                    self._ST = floor(self._ST + (self._ZZX - 200000) * 0.45)
563                else:
564                    self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)
565          else:          else:
566              self._ZX = self._ZZX              self._ZX = self._ZZX
567              self._UP5_6()              self._UP5_6()
# Line 345  class LST: Line 577  class LST:
577    
578      def _UP5_6(self):      def _UP5_6(self):
579          self._X = self._ZX * 1.25          self._X = self._ZX * 1.25
580          self._UPTAB05()          self._UPTAB07()
581          self._ST1 = self._ST          self._ST1 = self._ST
582          self._X = self._ZX * 0.75          self._X = self._ZX * 0.75
583          self._UPTAB05()          self._UPTAB07()
584          self._ST2 = self._ST          self._ST2 = self._ST
585          self._DIFF = (self._ST1 - self._ST2) * 2          self._DIFF = (self._ST1 - self._ST2) * 2
586          self._MIST = floor(self._ZX * 0.15)          self._MIST = floor(self._ZX * 0.15)
# Line 388  class LST: Line 620  class LST:
620              self._ANTEIL2 = ceil(self._JW * 7 / 360.0)              self._ANTEIL2 = ceil(self._JW * 7 / 360.0)
621          else:          else:
622              self._ANTEIL1 = floor(self._JW / 360.0)              self._ANTEIL1 = floor(self._JW / 360.0)
623              self._ANTEIL2 = ceil(self._JW / 360.0)                          self._ANTEIL2 = ceil(self._JW / 360.0)
624    
625      def _UPTAB05(self):      def _UPTAB07(self):
626          if self._X < 7665:          if self._X < 7665:
627              self._ST = 0              self._ST = 0
628          elif self._X < 12740:          elif self._X < 12740:
# Line 404  class LST: Line 636  class LST:
636              self._RW += 2397              self._RW += 2397
637              self._RW *= self._Y              self._RW *= self._Y
638              self._ST = floor(self._RW + 989)              self._ST = floor(self._RW + 989)
639          else:          elif self._X < 250001:
640              self._ST = floor(self._X * 0.42 - 7914)              self._ST = floor(self._X * 0.42 - 7914)
641            else:
642                self._ST = floor(self._X * 0.45 - 15414)
643          self._ST *= self._KZTAB          self._ST *= self._KZTAB
644    
645      def _MSONST(self):      def _MSONST(self):
646          if self.SONSTB > 0:          # ------------------------------
647              # ------------------------------          # Nicht im offiziellen Programm-
648              # Nicht im offiziellen Programm-          # ablaufplan: Attribute sichern
649              # ablaufplan: Attribute sichern          old_lzz = self.LZZ
650              old_lzz = self.LZZ          # ------------------------------
651              old_vbez = self.VBEZ          self.LZZ = 1
652              old_re4 = self.RE4          if self.ZMVB == 0:
653              # ------------------------------              self.ZMVB = 12
654              self.LZZ = 1          if self.SONSTB == 0:
655              self.VBEZ = self.JVBEZ              self._LSTSO = 0
656              self.RE4 = self.JRE4              self.STS = 0
657              self._MRE4LZZ()              self.SOLZS = 0
658              self._MRE4LZZ2()              self.BKS = 0
659              self._MRE4()          else:
660              self._MZTABFB()              self._MOSONST()
661              self._MLSTJAHR()              self._ZRE4J = (self.JRE4 + self.SONSTB) / 100
662              self._LST1 = self._ST * 100              self._ZVBEZJ = (self.JVBEZ + self.VBS) / 100
663              self.VBEZ = self.JVBEZ + self.VBS              self._MRE4SONST()
             self.RE4 = self.JRE4 + self.SONSTB  
             self._MRE4LZZ()  
             self._MRE4LZZ2()  
             self._MRE4()  
664              self._MLSTJAHR()              self._MLSTJAHR()
665              self._LST2 = self._ST * 100              self._LSTSO = self._ST * 100
666              self.STS = self._LST2 - self._LST1              self.STS = self._LSTSO - self._LSTOSO
667              self.SOLZS = self.STS * 5.5 / 100              if self.STS < 0:
668                    self.STS = 0
669                self.SOLZS = floor(self.STS * 5.5 / 100)
670              if self.R > 0:              if self.R > 0:
671                  self.BKS = self.STS                  self.BKS = self.STS
672              else:              else:
673                  self.BKS = 0                  self.BKS = 0
674              # ------------------------------          # ------------------------------
675              # Nicht im offiziellen Programm-          # Nicht im offiziellen Programm-
676              # ablaufplan: Attribute          # ablaufplan: Attribute
677              # wiederherstellen          # wiederherstellen
678              self.LZZ = old_lzz          self.LZZ = old_lzz
679              self.VBEZ = old_vbez          # ------------------------------
             self.RE4 = old_re4  
             # ------------------------------  
         else:  
             self.STS = 0  
             self.SOLZS = 0  
             self.BKS = 0  
   
     def _MRE4LZZ2(self):  
         self._RE4LZZ = self.RE4 - self._FVB - self._ALTE \  
                        - self.JFREIB + self.JHINZU  
         self._RE4LZZV = self.RE4 - self._FVB - self._ALTE  
680    
681      def _MVMT(self):      def _MVMT(self):
682          if self.VMT > 0:          if self.VKAPA < 0:
683              # ------------------------------              self.VKAPA = 0
684              # Nicht im offiziellen Programm-          if (self.VMT + self.VKAPA) > 0:
685              # ablaufplan: Attribute sichern              if self._LSTOSO == 0:
686              old_lzz = self.LZZ                  self._MOSONST()
687              old_vbez = self.VBEZ                  self._LSTOSO = self._LST1
688              old_re4 = self.RE4              else:
689              # ------------------------------                    self._LSTSO = self._LST1
690              self.LZZ = 1              self._ZRE4OSO = self._ZRE4
691              self.VBEZ = self.JVBEZ + self.VBS              self._ZTABFBOSO = self._ZTABFB
692              self.RE4 = self.JRE4 + self.SONSTB              self._FVBZOSO = self._FVBZ
693              self._MRE4LZZ()              self._ZRE4J = (self._ZRE4 + self.SONSTB + self.VBS + self.VKAPA) / 100
694              self._MRE4LZZ2()              self._MRE4SONST()
             self._MRE4()  
             self._MZTABFB()  
             self._MLSTJAHR()  
             self._LST1 = self._ST * 100  
             self.RE4 = self.JRE4 + self.SONSTB + self.VMT  
             self._MRE4LZZ()  
             self._MRE4LZZ2()  
             self._MRE4()  
             self._KENNZ = 1  
             self._ZRE4VP1 = self._ZRE4VP  
695              self._MLSTJAHR()              self._MLSTJAHR()
696              self._LST3 = self._ST * 100              self._LST3 = self._ST * 100
697              self.RE4 = self.JRE4 + self.SONSTB              self._ZTABFB = self._ZTABFB - self._FVBZ + self._FVBZOSO
698              self._MRE4LZZ()              self._KENNVMT = 1
699              self.RE4 = self.JRE4 + self.SONSTB + self.VMT / 5              if (self.RE4 + self.SONSTB - self.JFREIB + self.JHINZU) < 0:
700              self._MRE4LZZ2()                  self._KENNVMT = 2
701              self._MRE4()                  self._MLSTJAHR()
702              self._MLSTJAHR()                  self._LST2 = self._ST * 100
703              self._LST2 = self._ST * 100                  self.STV = self._LST2 * 5
704              self.STV = (self._LST2 - self._LST1) * 5              else:
705                    self._ZRE4VMT = (self.VMT / 100 + self.VKAPA / 100
706                                     - self._ZTABFB + self._ZTABFBOSO) / 5
707                    self._MLSTJAHR()
708                    self._LST2 = self._ST * 100
709                    self.STV = (self._LST2 - self._LST1) * 5
710              self._LST3 -= self._LST1              self._LST3 -= self._LST1
711              if self._LST3 < self.STV:              if self._LST3 < self.STV:
712                  self.STV = self._LST3                  self.STV = self._LST3
713                if self.STV < 0:
714                    self.STV = 0
715              self.SOLZV = floor(self.STV * 5.5 / 100)              self.SOLZV = floor(self.STV * 5.5 / 100)
716              if self.R > 0:              if self.R > 0:
717                  self.BKV = self.STV                  self.BKV = self.STV
718              else:              else:
719                  self.BKV = 0                  self.BKV = 0
             # ------------------------------  
             # Nicht im offiziellen Programm-  
             # ablaufplan: Attribute  
             # wiederherstellen  
             self.LZZ = old_lzz  
             self.VBEZ = old_vbez  
             self.RE4 = old_re4  
             # ------------------------------  
720          else:          else:
721              self.STV = 0              self.STV = 0
722              self.SOLZV = 0              self.SOLZV = 0
723              self.BKV = 0              self.BKV = 0
724    
725        def _MOSONST(self):
726            self._ZRE4J = self.JRE4 / 100
727            self._ZVBEZJ = self.JVBEZ / 100
728            self._JLFREIB = self.JFREIB / 100
729            self._JLHINZU = self.JHINZU / 100
730            self._MRE4()
731            self._MRE4ABZ()
732            self._MZTABFB()
733            self._MLSTJAHR()
734            self._LSTOSO = self._ST * 100
735    
736        def _MRE4SONST(self):
737            self._MRE4()
738            self._FVBSO = self._FVB
739            self._MRE4ABZ()
740            self._FVBZSO = self._FVBZ
741            self._MZTABFB()
742    
743      # Methoden zum gepr�ften setzen der Wert      # Methoden zum gepr�ften setzen der Wert
744      # FIX ME: Pr�fung _sehr_ unvollst�ndig      # FIX ME: Pr�fung _sehr_ unvollst�ndig
745      def Set_RE4(self, value):  
746          assert value >= 0, "must not be negative"      def Set_AJAHR(self, value):
747          self.RE4 = value          assert type(value) == type(0), "must be integer"
748            assert value >= 1900, "must be greater than 1900"
749            self.AJAHR = value
750    
751      def Set_ALTER1(self, value):      def Set_ALTER1(self, value):
752          assert value in (0,1), "must be 0 or 1"          assert value in (0,1), "must be 0 or 1"
753          self.ALTER1 = value          self.ALTER1 = value
754            
     def Set_HINZUR(self, value):  
         self.HINZUR = value  
           
755      def Set_JFREIB(self, value):      def Set_JFREIB(self, value):
756          self.JFREIB = value          self.JFREIB = value
757            
758      def Set_JHINZU(self, value):      def Set_JHINZU(self, value):
759          self.JHINZU = value          self.JHINZU = value
760            
761      def Set_JRE4(self, value):      def Set_JRE4(self, value):
762          self.JRE4 = value          self.JRE4 = value
763            
764      def Set_JVBEZ(self, value):      def Set_JVBEZ(self, value):
765          self.JVBEZ = value          self.JVBEZ = value
766            
767      def Set_KRV(self, value):      def Set_KRV(self, value):
768          assert value in (0,1), "must be 0 or 1"          assert value in (0,1,2), "must be 0, 1 or 2"
769          self.KRV = value          self.KRV = value
770            
771      def Set_LZZ(self, value):      def Set_LZZ(self, value):
772          assert value in (1,2,3,4), \          assert value in (1,2,3,4), \
773                 "must be in range 1-4 (JAHR, MONAT, WOCHE, TAG)"                 "must be in range 1-4 (JAHR, MONAT, WOCHE, TAG)"
774          self.LZZ = value          self.LZZ = value
775            
776        def Set_LZZFREIB(self, value):
777            self.LZZFREIB = value
778    
779        def Set_LZZHINZU(self, value):
780            self.LZZHINZU = value
781    
782      def Set_R(self, value):      def Set_R(self, value):
783          assert value >= 0.0 and value <= 100.0, \          assert value >= 0.0 and value <= 100.0, \
784                 "must be in range 0.0-100.0 (Percent)"                 "must be in range 0.0-100.0 (Percent)"
785          self.R = value          self.R = value
786            
787        def Set_RE4(self, value):
788            assert value >= 0, "must not be negative"
789            self.RE4 = value
790    
791      def Set_SONSTB(self, value):      def Set_SONSTB(self, value):
792          self.SONSTB = value          self.SONSTB = value
793            
794        def Set_STERBE(self, value):
795            self.STERBE = value
796    
797      def Set_STKL(self, value):      def Set_STKL(self, value):
798          assert value in (1,2,3,4,5,6), \          assert value in (1,2,3,4,5,6), \
799                 "must be in range 1-6 (I II III IV V VI)"                 "must be in range 1-6 (I II III IV V VI)"
800          self.STKL = value          self.STKL = value
801            
802      def Set_VBEZ(self, value):      def Set_VBEZ(self, value):
803          self.VBEZ = value          self.VBEZ = value
804    
# Line 571  class LST: Line 811  class LST:
811      def Set_VBS(self, value):      def Set_VBS(self, value):
812          self.VBS = value          self.VBS = value
813    
814        def Set_VJAHR(self, value):
815            self.VJAHR = value
816    
817        def Set_VKAPA(self, value):
818            self.VKAPA = value
819    
820      def Set_VMT(self, value):      def Set_VMT(self, value):
821          self.VMT = value          self.VMT = value
822    
     def Set_WFUNDF(self, value):  
         self.WFUNDF = value  
   
823      def Set_ZKF(self, value):      def Set_ZKF(self, value):
824          assert float(value) == float("%.1f" % value) and \          assert float(value) == float("%.1f" % value) and \
825                 value >= 0, \                 value >= 0, \
826                 "must be positive, and must not have more than one decimal digit"                 "must be positive, and must not have more than one decimal digit"
827          self.ZKF = value          self.ZKF = value
828            
829      def Set_ZMVB(self, value):      def Set_ZMVB(self, value):
830          self.ZMVB = value          self.ZMVB = value
831    
# Line 593  class LST: Line 836  class LST:
836  # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrj�hrigen  # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrj�hrigen
837  # Bez�gen und Sonstigen Leistungen.  # Bez�gen und Sonstigen Leistungen.
838    
839  class LStRechner2005(LST):  class LStRechner2008(LST):
840      def __init__(self):      def __init__(self):
841          LST.__init__(self)          LST.__init__(self)
842        
843        def SetGeb(self, geb):
844            """Setzt das Geburtsjahr"""
845            self.Set_AJAHR(geb + 65)
846            if self.AJAHR <= 2008:
847                self.Set_ALTER1(1)
848            else:
849                self.Set_ALTER1(0)
850    
851      def SetLohn(self, lohn):      def SetLohn(self, lohn):
852          """Setzt Lohn in Euro.Cent"""          """Setzt Lohn in Euro.Cent"""
853          self.Set_RE4(round (lohn * 100.0))          self.Set_RE4(round (lohn * 100.0))
Legend:
Removed from v.37  
changed lines
  Added in v.77
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26