12
$\begingroup$

I only have a little coding experience in C, and I remember I was told that pass by reference is more efficient than pass by value since the parameters don't need to be copied. Since there is no pass by reference in Mathematica, I'm wondering if that affects the performance of function calls, especially when dealing with large data?

Improve this question
$\endgroup$
7
  • 2
    $\begingroup$ This excellent answer by @Szabolcs probably addresses most of this question. $\endgroup$
    – Leonid Shifrin
    Commented Mar 8, 2013 at 1:05
  • $\begingroup$ @Nasser Actually, the question you linked is relevant, but only tangentially. Besides, the accepted answer there promotes dangerous practice of using Unevaluated, which is a wrong thing to do from the software development perspective. Instead, Hold- attributes should be used, as I emphasized in my answer there, and then also here. $\endgroup$
    – Leonid Shifrin
    Commented Mar 8, 2013 at 1:12
  • $\begingroup$ Thanks @Leonid, I actually forgot about that one and I was preparing to write something similar. @ All, I nominated that one for migration now, please vote if you think it's a good candidate. $\endgroup$
    – Szabolcs
    Commented Mar 8, 2013 at 1:47
  • $\begingroup$ You will find that despite some superficial similarities, C (and indeed virtually every other language) is a very poor model for how Mathematica actually works and many conclusions are not at all transferrable even at a conceptual level. In this case one may perhaps say that although the semantics of function calls with unheld arguments are isomorphic to passing by value, the implementation is rather different. Long story short: arguments are not copied. $\endgroup$
    – Oleksandr R.
    Commented Mar 8, 2013 at 3:15
  • 1
    $\begingroup$ If you want to change the object then using HoldXXX attributes to emulate by-reference is essential. If you do not make alterations then, as others have stated, the usual evaluation mode is fine. It is similar to by-value but it does not copy expressions, instead incrementing a reference counter and decrementing it when finished. $\endgroup$
    – Daniel Lichtblau
    Commented Mar 8, 2013 at 15:15

1 Answer 1

Reset to default
12
$\begingroup$

In Mathematica, this does not affect performance because copying does not take place most of the time. To put it simply, Mathematica implements copy-on-demand: it creates a copy of the data structure only if it is modified. Please see this answer for a more detailed explanation:

Does passing a variable with a large amount of data cost a lot of memory and time in Mathematica?

Improve this answer
$\endgroup$
1
  • 6
    $\begingroup$ I think @Nasser makes a valid point. When one needs to modify something inside a function, passing symbol (variable) where that something is stored, by reference, greatly reduces the overhead of modification, since it is done in place. I actually also felt that this is worth mentioning back then, see my last comment to your answer on SO. $\endgroup$
    – Leonid Shifrin
    Commented Mar 8, 2013 at 2:19

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.