Amortizacija u pythonu

In [1]:
import platform
In [2]:
platform.platform()
Out[2]:
'Linux-4.19.6-1-MANJARO-x86_64-with-arch-Manjaro-Linux'
In [3]:
platform.python_version()
Out[3]:
'3.7.1'
In [4]:
import matplotlib
In [5]:
matplotlib.__version__
Out[5]:
'3.0.2'
In [6]:
from pylab import *
In [7]:
import numpy as np
In [8]:
np.__version__
Out[8]:
'1.15.4'

Implementacija funkcija

In [9]:
from ipy_table import *

Funkcija amortizacija daje amortizacijsku osnovicu za zadanu vremensku metodu amortizacije. Funkcija ima sljedeće parametre:

  • C - početna vrijednost dobra
  • S - otpisna vrijednost dobra
  • n - broj godina trajanja amortizacije
  • metoda - vrsta vremenske amortizacije. Po defaultu je stavljeno metoda='LIN' što znači da se radi o linearnoj amortizaciji. Ako stavimo metoda='SZ', tada se radi amortizacija metodom sume znamenaka. Ako stavimo metoda='KP', tada se radi amortizacija metodom konstantnog postotka.
  • decimale - Na koliko decimala želimo ispisati rezultate. Po defaultu je stavljeno decimale=2.
  • izlaz - u kojem obliku želimo ispisati amortizaciju. Ako je izlaz='rjecnik', tada se rezultati ispisuju u obliku rječnika. Ako je izlaz='html', tada se rezultati ispisuju u obliku html tablice.
In [10]:
def amortizacija(C,S,n,metoda='LIN',izlaz='html',decimale=2):
    rjecnik = {0:{'R':0,'D':0,'B':C}}
    if metoda == 'LIN':
        Rk = round((C - S) / n, decimale) if (decimale > 0) else int((C - S) / n)
        for k in range(1,n+1):
            rjecnik[k] = {}
            rjecnik[k]['R'] = Rk
            rjecnik[k]['D'] = round(rjecnik[k-1]['D'] + Rk, decimale) if (decimale > 0) else int(rjecnik[k-1]['D'] + Rk)
            rjecnik[k]['B'] = round(C - rjecnik[k]['D'], decimale) if (decimale > 0) else int(C - rjecnik[k]['D'])
    elif metoda == 'SZ':
        suma = sum(range(1,n+1))
        for k in range(1,n+1):
            rjecnik[k] = {}
            Rk = round((n - k + 1) / suma * (C - S),decimale) if (decimale > 0) else int((n - k + 1) / suma * (C - S))
            rjecnik[k]['R'] = Rk
            rjecnik[k]['D'] = round(rjecnik[k-1]['D'] + Rk, decimale) if (decimale > 0) else int(rjecnik[k-1]['D'] + Rk)
            rjecnik[k]['B'] = round(C - rjecnik[k]['D'], decimale) if (decimale > 0) else int(C - rjecnik[k]['D'])
    elif metoda == 'KP':
        d = 100 * (1 - (S / C)**(1/n))
        for k in range(1,n+1):
            rjecnik[k] = {}
            Rk = round(rjecnik[k-1]['B'] * d /100, decimale) if (decimale > 0) else int(rjecnik[k-1]['B'] * d /100)
            rjecnik[k]['R'] = Rk
            rjecnik[k]['D'] = round(rjecnik[k-1]['D'] + Rk, decimale) if (decimale > 0) else int(rjecnik[k-1]['D'] + Rk)
            rjecnik[k]['B'] = round(C - rjecnik[k]['D'], decimale) if (decimale > 0) else int(C - rjecnik[k]['D'])
    else:
        return "varijabla 'metoda' mora poprimiti neku od tri vrijednosti: 'LIN', 'SZ', 'KP'"
    if izlaz == 'rjecnik':
        return rjecnik
    elif izlaz == 'html':
        tablica = [['$k$','$R_k$','$D_k$','$B_k$'],[0,'$-$','$-$',C]]
        for k in range(1,n+1):
            tablica.append([])
            tablica[-1].extend([k,rjecnik[k]['R'],rjecnik[k]['D'],rjecnik[k]['B']])
        tablica = make_table(tablica)
        apply_theme('basic')
        set_global_style(align='center')
        set_global_style(float_format='%0.{}f'.format(decimale))
        return tablica

Funkcija funkcionalna_amortizacija daje amortizacijsku osnovicu za funkcionalnu amortizaciju. Funkcija ima sljedeće parametre:

  • C - početna vrijednost dobra
  • S - otpisna vrijednost dobra
  • n - broj godina trajanja amortizacije
  • pk - lista brojeva koji opisuju intenzitet trošenja dobra u pojedinoj godini.
  • decimale - Na koliko decimala želimo ispisati rezultate. Po defaultu je stavljeno decimale=2.
  • izlaz - u kojem obliku želimo ispisati amortizaciju. Ako je izlaz='rjecnik', tada se rezultati ispisuju u obliku rječnika. Ako je izlaz='html', tada se rezultati ispisuju u obliku html tablice.
In [11]:
def funkcionalna_amortizacija(C,S,n,pk,izlaz='html',decimale=2):
    rjecnik = {0:{'p':0,'R':0,'D':0,'B':C}}
    a = (C - S) / sum(pk)
    for k in range(1,n+1):
        rjecnik[k] = {}
        Rk = round(pk[k-1] * a, decimale) if (decimale > 0) else int(pk[k-1] * a)
        rjecnik[k]['p'] = pk[k-1]
        rjecnik[k]['R'] = Rk
        rjecnik[k]['D'] = round(rjecnik[k-1]['D'] + Rk, decimale) if (decimale > 0) else int(rjecnik[k-1]['D'] + Rk)
        rjecnik[k]['B'] = round(C - rjecnik[k]['D'], decimale) if (decimale > 0) else int(C - rjecnik[k]['D'])
    if izlaz == 'rjecnik':
        return rjecnik
    elif izlaz == 'html':
        tablica = [['$k$','$p_k$','$R_k$','$D_k$','$B_k$'],[0,'$-$','$-$','$-$',C]]
        for k in range(1,n+1):
            tablica.append([])
            tablica[-1].extend([k,rjecnik[k]['p'],rjecnik[k]['R'],rjecnik[k]['D'],rjecnik[k]['B']])
        tablica = make_table(tablica)
        apply_theme('basic')
        set_global_style(align='center')
        set_global_style(float_format='%0.{}f'.format(decimale))
        return tablica

Vremenska amortizacija

Zadatak

Oprema čija je cijena $400\,000$ kuna ima životni vijek 5 godina i otpisnu vrijednost $100\,000$ kuna. Napravite amortizacijsku tablicu koristeći linearnu metodu.

Rješenje

In [12]:
amortizacija(400000,100000,5,izlaz='rjecnik')
Out[12]:
{0: {'R': 0, 'D': 0, 'B': 400000},
 1: {'R': 60000.0, 'D': 60000.0, 'B': 340000.0},
 2: {'R': 60000.0, 'D': 120000.0, 'B': 280000.0},
 3: {'R': 60000.0, 'D': 180000.0, 'B': 220000.0},
 4: {'R': 60000.0, 'D': 240000.0, 'B': 160000.0},
 5: {'R': 60000.0, 'D': 300000.0, 'B': 100000.0}}
In [13]:
amortizacija(400000,100000,5,izlaz='rjecnik',decimale=0)
Out[13]:
{0: {'R': 0, 'D': 0, 'B': 400000},
 1: {'R': 60000, 'D': 60000, 'B': 340000},
 2: {'R': 60000, 'D': 120000, 'B': 280000},
 3: {'R': 60000, 'D': 180000, 'B': 220000},
 4: {'R': 60000, 'D': 240000, 'B': 160000},
 5: {'R': 60000, 'D': 300000, 'B': 100000}}
In [14]:
amortizacija(400000,100000,5,metoda='LIN')
Out[14]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
160000.0060000.00340000.00
260000.00120000.00280000.00
360000.00180000.00220000.00
460000.00240000.00160000.00
560000.00300000.00100000.00
In [15]:
amortizacija(400000,100000,5,decimale=0)
Out[15]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
16000060000340000
260000120000280000
360000180000220000
460000240000160000
560000300000100000

slika

Knjigovodstvena vrijednost kod linearne amortizacije je linearna funkcija vremena.

In [16]:
np.polyfit([0,1,2,3,4,5],[400000,340000,280000,220000,160000,100000],1)
Out[16]:
array([-60000., 400000.])
In [17]:
figure(figsize=(10,8))
x=arange(0,5,0.01)
fx= list(map(lambda x: -60000*x+400000, x))
plot(x,fx,c='r',lw=3)
dx=[0,1,2,3,4,5]
dy=list(map(lambda x: -60000*x+400000, dx))
plot(dx,dy,c='y',ls='',marker='o',ms=10,markeredgecolor='k')
text(3.35,370000, "linearna funkcija", color='blue', fontsize=16,
        bbox=dict(facecolor='#FCF3CF', edgecolor='blue', boxstyle='round,pad=0.8'))
xlabel('k',fontsize=16)
ylabel('$B_k$',fontsize=16)
grid(True)

Zadatak

Oprema čija je cijena $400\,000$ kuna ima životni vijek 5 godina i otpisnu vrijednost $100\,000$ kuna. Napravite amortizacijsku tablicu koristeći metodu sume znamenaka.

Rješenje

In [18]:
amortizacija(400000,100000,5,izlaz='rjecnik',metoda='SZ')
Out[18]:
{0: {'R': 0, 'D': 0, 'B': 400000},
 1: {'R': 100000.0, 'D': 100000.0, 'B': 300000.0},
 2: {'R': 80000.0, 'D': 180000.0, 'B': 220000.0},
 3: {'R': 60000.0, 'D': 240000.0, 'B': 160000.0},
 4: {'R': 40000.0, 'D': 280000.0, 'B': 120000.0},
 5: {'R': 20000.0, 'D': 300000.0, 'B': 100000.0}}
In [19]:
amortizacija(400000,100000,5,izlaz='rjecnik',decimale=0,metoda='SZ')
Out[19]:
{0: {'R': 0, 'D': 0, 'B': 400000},
 1: {'R': 100000, 'D': 100000, 'B': 300000},
 2: {'R': 80000, 'D': 180000, 'B': 220000},
 3: {'R': 60000, 'D': 240000, 'B': 160000},
 4: {'R': 40000, 'D': 280000, 'B': 120000},
 5: {'R': 20000, 'D': 300000, 'B': 100000}}
In [20]:
amortizacija(400000,100000,5,izlaz='html',metoda='SZ')
Out[20]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
1100000.00100000.00300000.00
280000.00180000.00220000.00
360000.00240000.00160000.00
440000.00280000.00120000.00
520000.00300000.00100000.00
In [21]:
amortizacija(400000,100000,5,decimale=0,metoda='SZ')
Out[21]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
1100000100000300000
280000180000220000
360000240000160000
440000280000120000
520000300000100000

slika

Knjigovodstvena vrijednost kod amortizacije metodom sume znamenaka je kvadratna funkcija vremena.

In [22]:
np.polyfit([0,1,2,3,4,5],[400000,300000,220000,160000,120000,100000],2)
Out[22]:
array([  10000., -110000.,  400000.])
In [23]:
figure(figsize=(10,8))
x=arange(0,5,0.01)
fx= list(map(lambda x: 10000*x**2-110000*x+400000, x))
plot(x,fx,c='r',lw=3)
dx=[0,1,2,3,4,5]
dy=list(map(lambda x: 10000*x**2-110000*x+400000, dx))
plot(dx,dy,c='y',ls='',marker='o',ms=10,markeredgecolor='k')
text(3.25,370000, "kvadratna funkcija", color='blue', fontsize=16,
        bbox=dict(facecolor='#FCF3CF', edgecolor='blue', boxstyle='round,pad=0.8'))
xlabel('k',fontsize=16)
ylabel('$B_k$',fontsize=16)
grid(True)

Zadatak

Oprema čija je cijena $400\,000$ kuna ima životni vijek 5 godina i otpisnu vrijednost $100\,000$ kuna. Napravite amortizacijsku tablicu koristeći metodu konstantnog postotka.

Rješenje

In [24]:
amortizacija(400000,100000,5,izlaz='rjecnik',metoda='KP')
Out[24]:
{0: {'R': 0, 'D': 0, 'B': 400000},
 1: {'R': 96856.69, 'D': 96856.69, 'B': 303143.31},
 2: {'R': 73403.64, 'D': 170260.33, 'B': 229739.67},
 3: {'R': 55629.56, 'D': 225889.89, 'B': 174110.11},
 4: {'R': 42159.32, 'D': 268049.21, 'B': 131950.79},
 5: {'R': 31950.79, 'D': 300000.0, 'B': 100000.0}}
In [25]:
amortizacija(400000,100000,5,metoda='KP')
Out[25]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
196856.6996856.69303143.31
273403.64170260.33229739.67
355629.56225889.89174110.11
442159.32268049.21131950.79
531950.79300000.00100000.00

slika

Knjigovodstvena vrijednost kod amortizacije metodom konstantnog postotka je eksponencijalna funkcija vremena.

In [26]:
figure(figsize=(10,8))
x=arange(0,5,0.01)
d=100*(1-(100000/400000)**(1/5))
fx= list(map(lambda x: 400000*(1-d/100)**x, x))
plot(x,fx,c='r',lw=3)
dx=[0,1,2,3,4,5]
dy=list(map(lambda x: 400000*(1-d/100)**x, dx))
plot(dx,dy,c='y',ls='',marker='o',ms=10,markeredgecolor='k')
text(2.7,370000, "eksponencijalna funkcija", color='blue', fontsize=16,
        bbox=dict(facecolor='#FCF3CF', edgecolor='blue', boxstyle='round,pad=0.8'))
xlabel('k',fontsize=16)
ylabel('$B_k$',fontsize=16)
grid(True)

Usporedba vremenskih metoda amortizacije

Odnos knjigovodstvenih vrijednosti kod metode sume znamenaka i metode konstantnog postotka bitno ovisi i o početnim podacima.

$C=400\,000,\quad S=100\,000,\quad n=5$

In [27]:
figure(figsize=(10,8))
x=arange(0,5,0.01)
LINx= list(map(lambda x: -60000*x+400000, x))
SZx= list(map(lambda x: 10000*x**2-110000*x+400000, x))
KPx= list(map(lambda x: 400000*(1-d/100)**x, x))
plot(x,LINx,lw=3,label='linearna amortizacija')
plot(x,SZx,lw=3,label='metoda sume znamenaka')
plot(x,KPx,lw=3,label='metoda konstantnog postotka')
dx=[0,5]
dy=[400000,100000]
plot(dx,dy,c='cyan',ls='',marker='o',ms=10,markeredgecolor='k')
xlabel('k',fontsize=16)
ylabel('$B_k$',fontsize=16)
legend()
grid(True)

$C=400\,000,\quad S=50\,000,\quad n=5$

In [28]:
amortizacija(400000,50000,5,metoda='LIN')
Out[28]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
170000.0070000.00330000.00
270000.00140000.00260000.00
370000.00210000.00190000.00
470000.00280000.00120000.00
570000.00350000.0050000.00
In [29]:
amortizacija(400000,50000,5,metoda='SZ')
Out[29]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
1116666.67116666.67283333.33
293333.33210000.00190000.00
370000.00280000.00120000.00
446666.67326666.6773333.33
523333.33350000.0050000.00
In [30]:
amortizacija(400000,50000,5,metoda='KP')
Out[30]:
$k$$R_k$$D_k$$B_k$
0$-$$-$400000
1136098.42136098.42263901.58
289791.47225889.89174110.11
359240.28285130.17114869.83
439084.01324214.1875785.82
525785.83350000.0149999.99
In [31]:
kl=np.polyfit([0,1,2,3,4,5],[400000,330000,260000,190000,120000,50000],1)
kl
Out[31]:
array([-70000., 400000.])
In [32]:
ksz=np.polyfit([0,1,2,3,4,5],[400000,283333.33,190000,120000,73333.33,50000],2)
ksz
Out[32]:
array([  11666.66678571, -128333.33392857,  399999.99928571])
In [33]:
figure(figsize=(10,8))
x=arange(0,5,0.01)
d=100*(1-(50000/400000)**(1/5))
LINx= list(map(lambda x: kl[0]*x+kl[1], x))
SZx= list(map(lambda x: ksz[0]*x**2+ksz[1]*x+ksz[2], x))
KPx= list(map(lambda x: 400000*(1-d/100)**x, x))
plot(x,LINx,lw=3,label='linearna amortizacija')
plot(x,SZx,lw=3,label='metoda sume znamenaka')
plot(x,KPx,lw=3,label='metoda konstantnog postotka')
dx=[0,5]
dy=[400000,50000]
plot(dx,dy,c='cyan',ls='',marker='o',ms=10,markeredgecolor='k')
xlabel('k',fontsize=16)
ylabel('$B_k$',fontsize=16)
legend()
grid(True)

Funkcionalna amortizacija

Zadatak

Izradite amortizacijsku osnovicu za stroj čija je vrijednost $60\,000$ kuna, a otpisna $8\,000$ kuna. Predviđeni vijek trajanja stroja je 4 godine, a tijekom tih godina njegov je učinak po broju proizvoda dan u donjoj tablici.

godina 1. 2. 3. 4.
broj proizvoda 4000 3500 2900 2600

Rješenje

In [34]:
funkcionalna_amortizacija(60000,8000,4,[4000,3500,2900,2600])
Out[34]:
$k$$p_k$$R_k$$D_k$$B_k$
0$-$$-$$-$60000
1400016000.0016000.0044000.00
2350014000.0030000.0030000.00
3290011600.0041600.0018400.00
4260010400.0052000.008000.00
In [35]:
funkcionalna_amortizacija(60000,8000,4,[4000,3500,2900,2600],decimale=0)
Out[35]:
$k$$p_k$$R_k$$D_k$$B_k$
0$-$$-$$-$60000
14000160001600044000
23500140003000030000
32900116004160018400
4260010400520008000
In [36]:
funkcionalna_amortizacija(60000,8000,4,[4000,3500,2900,2600],izlaz='rjecnik')
Out[36]:
{0: {'p': 0, 'R': 0, 'D': 0, 'B': 60000},
 1: {'p': 4000, 'R': 16000.0, 'D': 16000.0, 'B': 44000.0},
 2: {'p': 3500, 'R': 14000.0, 'D': 30000.0, 'B': 30000.0},
 3: {'p': 2900, 'R': 11600.0, 'D': 41600.0, 'B': 18400.0},
 4: {'p': 2600, 'R': 10400.0, 'D': 52000.0, 'B': 8000.0}}
In [37]:
funkcionalna_amortizacija(60000,8000,4,[4000,3500,2900,2600],izlaz='rjecnik',decimale=0)
Out[37]:
{0: {'p': 0, 'R': 0, 'D': 0, 'B': 60000},
 1: {'p': 4000, 'R': 16000, 'D': 16000, 'B': 44000},
 2: {'p': 3500, 'R': 14000, 'D': 30000, 'B': 30000},
 3: {'p': 2900, 'R': 11600, 'D': 41600, 'B': 18400},
 4: {'p': 2600, 'R': 10400, 'D': 52000, 'B': 8000}}

slika

Funkcija knjigovodstvene vrijednosti ovisno o vremenu aproksimirana je linearnim splajnom (po dijelovima linearnom funkcijom). Naravno, možemo dobivene diskretne podatke interpolirati i nekom drugom funkcijom. Sve ovisi o konkretnom problemu i našem iskustvu s konkretnim realnim problemom na temelju kojeg biramo što je moguće precizniji model za kontinuirani slučaj.

Površina ispod linearnog splajna na segmentu $[k-1,k]$ zorno nam aproksimira intenzitet trošenja dobra u $k$-toj godini za $k\in\{1,2,3,4\}$.

In [38]:
figure(figsize=(10,8))
x=arange(0,4.01,0.01)
fx= list(map(lambda x: np.interp(x,[0,1,2,3,4],[60000,44000,30000,18400,8000]), x))
plot([0,4],[60000,8000],c='b',ls='--')
fill_between(x,0,fx,alpha=0.2,color='r')
plot(x,fx,c='r',lw=3)
dx=[0,1,2,3,4]
dy=[60000,44000,30000,18400,8000]
plot(dx,dy,c='y',ls='',marker='o',ms=10,markeredgecolor='k')
xlabel('k',fontsize=16)
ylabel('$B_k$',fontsize=16)
grid(True)
In [ ]: