Exporting relative Excel references using put_formula() in Mata - stata

Question

I am exporting a lot of strings from Stata to Excel.
For a single column of 3000+ rows with a different string in each, I need to check the length of each string/cell. I could do this in Stata using the length() function, but I need to be able to open the Excel file, edit a given string, and have the length update automatically in Excel.
This seems like it should be simple using the putexcel command or mata's put_formula() function, but the time to run is prohibitive.
At root, my question is about building many relative references (e.g., =LEN(A1)) in mata all at once, as opposed to one at a time.
This may make more sense after seeing the code below:
mata: b = xl()
mata: b.create_book("Formula_Test", "Formula_Test", "xlsx")
mata: b.load_book("Formula_Test")
*Put some strings in column 1
mata: b.put_string(1, 1, "asfas")
mata: b.put_string(2, 1, "sfhds")
mata: b.put_string(3, 1, "qwrq")
mata: b.put_string(4, 1, "dgsdgsdgsdgs")
*Formula - export one-at-a-time
*This works, but is slow
foreach i of numlist 1/4{
mata: b.put_formula(`i', 2, "LEN(A`i')")
}
*Formula - export all at once with relative reference
*This would be faster, but throws error
mata: b.put_formula((1,4), 3, "LEN(INDIRECT("C[-2]",FALSE))")
When I run the last line, I get an error:
invalid expression
r(3000);
Is there an efficient way to write an entire column or row of Excel formulas using mata, with relative references?

Answer 1

The mata function put_formula() only accepts scalars for rows and columns. Note that you also need to use compound double quotes in its string matrix argument.
Looping in mata is always faster than doing so in Stata:
mata:
for (i = 1; i <= 4; i++) {
b.put_formula(i, 2, `"LEN(INDIRECT("C[-2]",FALSE))"')
}
end
Nevertheless, despite the limitation of having to use scalars as arguments for rows and columns in put_formula(), a loop is in fact not necessary. This is because one can specify a string matrix J of constants as the final argument.
Indeed, the following does the same in seconds:
mata:
k = J(3000, 1, `"LEN(INDIRECT("C[-1]",FALSE))"')
b.put_formula(1, 2, k)
end
In this way, the matrix J[3000,1] is written once in cell B1 of the spreadsheet. Because it has 3000 rows, it naturally extends to all cells down to B3000.

Answer 2

This answer is secondary but may be useful to someone.
The inefficiency in the code in the question -- looping through a numlist and writing the formula in mata one cell at a time -- comes partially from the use of a Stata loop (as Pearly Spencer pointed out and corrected). But a bigger issue is the number of times mata has to write individual cells when the example is expanded from 4 cells to several thousand.
If you can avoid looping and writing many cells individually, using -putexcel- or mata's b.put_formula are not dramatically different in speed in most applications. If you are writing cells in a single column, row, or matrix of cells, and can write them all at once, either option will be fast. A -putexcel- example:
*A -putexcel- example
mata: b.create_book("Formula_Test", "Formula_Test", "xlsx")
putexcel set "Formula_Test", sheet("Formula_Test") modify
putexcel B1:B30000 = formula(`" =LEN(INDIRECT("C[-1]",FALSE)) "')
For 30,000 cells in a single column, -putexcel- took 37 seconds.
Using Pearly Spencer's J matrix approach in mata took 36 seconds.
The important point is: if you are writing a formula to many cells, try to consolidate it into blocks that can be written together as matrices, rather than looping over all cells. This will give you the biggest speed gains; using mata instead of -putexcel- will help, but will provide only a second-order improvement. Even in mata it will take a long time to write individually to thousands of cells.