I keep going in circles, do I use a macro, or do I use a function? How do I a get this
and this
as a dataframe
with one line of code.
These examples are from different sources, but the ledger(bottom) has each account as a title. The journal(top) documents one transaction (a row in the ledger), with the Name of each account(the columns of the ledger) that is modified in the transaction.
To process a transaction the sums of credit and debit must match.
This is what I have so far
using DataFrames
Ledger=DataFrame(
chequing=[0],
expenses=[0],
income=[0])
I want to create a function or a macro, which has a journal entry, with a unique identifier, a credited account (one to start but more later), a debited account(again one now, more later), the date of the transaction, and a memo (called description in sample ledger), that describes the transaction, but this is less important.
Iâm not sure how to make use of functions or macros (or another type of metaprograming) to accomplish this task.
This is a good start.
I have some problems with the english financial terms (ledger,checking,âŚ) , because I am not a finance person, but I think this is less important. More important is patience, we need to go step by step, no shortcuts.
First: lets cancel macros out of our minds. Why? Metaprogramming is about generating code, special syntax to generate code, in other words âprogramming programsâ, therefore the meta. It almost never makes sense to start with that. So: no macros for now.
If I understand it right: can we just concentrate on the ledger(s) for now? A journal can always be added later, isnât it?
Ok, next step? A function to add an entry to a ledger?
ledger=DataFrame(
date=[""],
chequing=[0],
expenses=[0],
income=[0])
new_row=(date="",chequing=[0],expenses=[0],income=[0])
function ledgertransaction(
new_date,
credit_account,
credit_amount,
debit_account,
debit_amount)
push!(ledger,new_row...,
date=new_date,
credit_account=credit_amount,
debit_account=debit_amount)
end
but when I execute :
ledgertransaction("Jan 1, 2000",expenses,100,chequing,100)
It says that expenses is not defined.
Use "expenses" not expenses.
that works, but if you look at DataFrames, thatâs not supposed to be a string.
The account name is always just a string, isnât it? The same way the amount is always just a number.
Is the column name a string? Iâm just trying to add a row to the DataFrame named âledgerâ.
No, but youâre not trying to use the column name, youâre just specifying the value that goes into the credit_account column for this row.
No, Iâm specifying the column that column_amount goes into. This is the ledger, not the journal.
Can we go to Zulipâs data channel, I think it will be easier to use than Discourse for this kind of thing.
OK, Zulip
If you are writing an accounting program using Julia, you should be using Decimal Floating Point instead of Binary Floating Point. This way, you can make sure that your cents add up correctlyâŚ
$ julia
_
_ _ _(_)_ | Documentation: https://docs.julialang.org
(_) | (_) (_) |
_ _ _| |_ __ _ | Type "?" for help, "]?" for Pkg help.
| | | | | | |/ _` | |
| | |_| | | | (_| | | Version 1.6.1 (2021-04-23)
_/ |\__'_|_|_|\__'_| | Official https://julialang.org/ release
|__/ |
julia> 0.1 + 0.1 + 0.1
0.30000000000000004
julia> using DFPs
[ Info: Precompiling DFPs [top-level]
julia> d"0.1" + d"0.1" + d"0.1" |> DFP_toCommonString
"0.3000000000000000"
You donât have access to DFPs (because it is my own private module) but there is a package called decimal I think that more or less does the same thing.
That was low down on my list now, but currently, Iâm using integers, this is indeed something I was going to ask about.
Here is a function that creates a journal entry and adds a row to the ledger.
function ledgertransaction(
#journal_entry,
date,
credit_account,
credit_amount,
debit_account,
debit_amount
)
default_row=Dict("chequing"=>0,"expenses"=>0,"income"=>0)
spec = Dict("date" => date, credit_account => credit_amount, debit_account => debit_amount)
row = merge(default_row, spec)
push!(ledger,row)
journal_entry=DataFrame(
date=["Jan 1, 2000","","",""],
credited_account=["", credit_account,"",""],
debited_account=["","",debit_account,""],
credit=[0,credit_amount,0,0],
debit=[0,0,debit_amount,0])
end
end
Good Morning, to all.
Great, something proceeded, but we need to analyze, what happened and whats wrong or confusing.
Therefor we still drop journal_entry, we are not yet there.
And currency roundings are also ignored for now, we stay with Int, as we are dealing with more basic problems.
The current working code is:
using DataFrames
ledger=DataFrame(
date=[""],
chequing=[0],
expenses=[0],
income=[0])
function ledgertransaction(
date,
credit_account,
credit_amount,
debit_account,
debit_amount
)
default_row=Dict("chequing"=>0,"expenses"=>0,"income"=>0)
spec = Dict("date" => date, credit_account => credit_amount, debit_account => debit_amount)
row = merge(default_row, spec)
push!(ledger,row)
end
ledgertransaction("Jan 1, 2000","expenses",100,"chequing",100)
It is working but there are some issues:
As the amount of the transactions must be equal, there is no need to pass the value 2 times. The function should therefor more look like:
ledgertransaction(date,amount,credit_account,debit_account)
As we change ledger we should write it as:
ledgertransaction!(ledger,...)
We shouldnât at this point return anything from ledgertransaction! (we should return nothing or true for no error and false for error)
If we change the ledger definition, e.g. adding more accounts as columns or adding the description column, we have to change our function, which is error prone. So, the function should be more generic, so that any ledger can be passed. (this is a bit advanced)
It is possible to pass accounts, which arenât present in the ledger. There needs to be some checking for this.
If credit_account and debit_account are given equal, only a single amount is accounted, which is an error. A check that those accounts a different is needed.
default_row isnât a default row, itâs only some default values for some columns. It should be named like that (see point 4.: create default_values generically)
Parameter date can be empty: check for not empty (at least)
As my aim is not to provide just something which works but isnât understood, I would suggest, that at first, we work on these issues before we proceed. This will also avoid those circles of confusion.
If you agree, take the following complete code, where the new function ledgertransaction! has already been changed (issue 1., 2. and 3., check what I have done to adress these issues, please) and comments and suggestions are filled in, but it is up to you, to make it complete (put your code where you see the #âŚ):
using DataFrames
ledger=DataFrame(
date=[""],
chequing=[0],
expenses=[0],
income=[0])
function ledgertransaction!(ledger,date,amount,credit_account,debit_account)
#check if date is not a empty string
if length(date) == 0
return false
end
#check if credit_account is different from debit_account:
#...
#check if credit_account exists:
if !( credit_account in names(ledger) )
return false
end
#check if debit_account exists:
#...
#create a default row more generically:
# this is advanced stuff, you may skip it for now
#...
# skipped for now, stay with the original non-generic code:
default_values=Dict("chequing"=>0,"expenses"=>0,"income"=>0)
spec = Dict("date" => date, credit_account => amount, debit_account => amount)
row = merge(default_values, spec)
push!(ledger,row)
return true
end
The following calls should do fine and return true if an entry was added or false if nothing was added because of any error:
ledgertransaction!(ledger,"Jan 1, 2000",100,"expenses","chequing")
ledgertransaction!(ledger,"Jan 1, 2000",10,"expenses","expenses")
ledgertransaction!(ledger,"Jan 1, 2000",20,"expenses","cheqing")
ledgertransaction!(ledger,"",30,"expenses","chequing")
another_ledger=DataFrame(
date=[""],
chequing=[0],
expenses=[0],
income=[0],
sum=[0]
)
ledgertransaction!(another_ledger,"Jan 1, 2000",100,"expenses","sum")
In this example, the additional column sum can be accessed like an account. Of course this is not what a sum is. So this still needs special coding and can not be generic as the meaning of sum is something different.
Give me some feedback, if itâs clear what I did in the code. And of course, the issues may need some discussion.
Whatever questions you have, letâs get them out of the way before you proceed.
I want to pass the value 2 times, because that way itâs easier to find a mistake.
Other than wanting to have both the credit and debit values, what you did looks really good. I changed the if statements, so that it can find all the errors. I guess lets work through the stuff for issue 4.
function ledgertransaction(
date,
credit_account,
credit_amount,
debit_account,
debit_amount
)
check=credit_amount-debit_amount
if length(date) == 0
"Error-- no date entered"
else
if !( credit_account in names(ledger) )
"Error-- credit account not found"
else
if !( debit_account in names(ledger) )
"Error--debit account not found"
else
if check != 0
"Error -- credit and debit must match."
else
default_row=Dict("chequing"=>0,"expenses"=>0,"income"=>0)
spec = Dict(
"date" => date,
credit_account => credit_amount,
debit_account => debit_amount)
row = merge(default_row, spec)
push!(ledger,row)
journal_entry=DataFrame(
date=["Jan 1, 2000","","",""],
credited_account=["", credit_account,"",""],
debited_account=["","",debit_account,""],
credit=[0,credit_amount,0,0],
debit=[0,0,debit_amount,0],
#balance=[0,
# sum(credit_account),
# sum(add_debit_account),
# 0]
#I need to figure out how to calculate my balance
)
end
end
end
end
end
Your new function has new issues.
(Thats how the circles start!)
A major issue is, that this new function returns the error strings in case of an error, but in case of no error, it returns journal_entry , which is type instability.
For details see Performance Tips ¡ The Julia Language
(Issue named âtype stableâ)
Another major issue is, that, as I said (but with not much detail) in issue 2, we are changing ledger. Doing it, like you in your newest function, this would need a global ledger. We want to avoid global variables, see Performance Tips ¡ The Julia Language
(Issue named âglobal variablesâ)
The goal for us is to implement your problem in a Julian way. Thatâs why I still hesitate to adress the journal_entry. For this I see a second function, which again should be implemented in Julian style.
If we do this now in a sloppy way (just producing working code) we will have problems later!
Passing the amount twice is ok, but errors must be handled, as you do. Fine.
The above two new issues, âtype stableâ and âglobal variablesâ) must be cleared, before we proceed! I have to insist 
Reading the performance tips i see that mixing types is an issue, the problem is that if it just returns false, it can take longer to find the error, is there a way around this?