Fdtxjr

Thanks to Bruno for suggesting that for my specific case, where my results come from Mathematica, it's simply much easier to change the output in there using trivial replacement rules. However, this stands alone as a general question.

This is a slightly different question to what I've seen before, where I can use something like newcommandgagamma to make shortcuts of things using .

I have a series of LONG equations with stuff like x[2] or a[3] in them. I want to be able to always replace any instance of them with something else, like a command that takes a string and replaces it like something similar to

newcommandx[2]x_2

and

newcommanda[2]beta

Ideally, this would take account of the number inside, but I could easily just do it for all instances that arise. Any guidance would be great (my document class is Report)

An extensible set of replacements:

documentclassarticle
usepackageamsmath
usepackagexparse

ExplSyntaxOn
NewDocumentCommandtransm
 
 tl_set:Nn l__brad_trans_tl #1 
 regex_replace_all:nnN [(.*?)] csbcB1cE l__brad_trans_tl
 regex_replace_all:nnN a calpha l__brad_trans_tl
 % other replacements
 % ...
 % deliver the new token list
 l__brad_trans_tl
 
ExplSyntaxOff

begindocument

$transx[1]+x[2]^2+a+a[3]$

enddocument

Inasmuch as I love doing crazy things in TeX, do the replacements in Mathematica! This will save you a huge amount of pain. For instance,

expr = (a[1] + a[2])/Sqrt[a[3]]
expr /. a[1] -> [Alpha], a[2] -> [Beta], a[3] -> [Gamma] // TeXForm

gives fracalpha +beta sqrtgamma with no need to tweak the output.

I really can not recommend doing this, but as you ask...

documentclassarticle

begindocument


mathcode`[="8000
mathcode`]="8000

catcode`[=active gdef[_bgroup
catcode`]=active gdef]egroup


hmmm
[
a[1]+a[2]+b[c+d[3]] + x
]

enddocument

Along the vein of my cited Translate in-line equations to TeX code (Any Package?), but a much simpler parsing request, I provide translate.

No catcode changes required. It will retain surrounding math style, etc.

documentclassarticle
usepackagelistofitems
newtokseqtoks
newcommandaddtoeqtoks[1]expandaftereqtoksexpandaftertheeqtoks#1
newcommandtranslate[1]%
 setsepchar[%
 readlistmyeqn#1%
 eqtoks%
 foreachitemxinmyeqn[]%
 ifnumxcnt=1else%
 if[myeqnsep[numexprxcnt-1]addtoeqtoks_bgroupfi%
 if]myeqnsep[numexprxcnt-1]addtoeqtoksegroupfi%
 fi%
 expandafteraddtoeqtoksexpandafterx%
 %
 theeqtoks%

begindocument
[
translatea[1]+a[2]+b[c+d[3]] + x
]
enddocument

For the sake of variety, here's a LuaLaTeX-based solution. It sets up a Lua function, called trans, which does most of the work with the help of Lua's versatile string-handling routines. The LaTeX macro trans is a wrapper that invokes the Lua function.

documentclassarticle
usepackageluacode % for "luacode" environment and "luastringN" macro
beginluacode

function makesubscr ( s )
 s = s:gsub ( "(%b[])", function(x)
 return ( "_" .. string.sub ( x , 2 , -2 ) .. "" )
 end )
 if s:find ( "%b[]" ) then 
 s = makesubscr ( s ) 
 end
 return s
end
function trans ( s )
 s = makesubscr ( s )
 s = s:gsub ( "a" , "\alpha" )
 s = s:gsub ( "b" , "\beta" )
 tex.sprint ( s )
end

endluacode

%% TeX-side code
newcommandtrans[1]directluatrans(luastringN#1)

begindocument
$transx[1]+x[2]^2+a+a[3]$

$transa[1]+a[2]+b[c+d[3]]+x$
enddocument

Here's a solution. The command addreplacementruletext-to-replacereplacement-text specifies replacements to make. Then the command replacesome math does the replacements.

This would probably be better done with the l3regex package or really find and replace as many other people mentioned.

documentclassarticle
makeatletter
newtoksri@activechars
defaddreplacementrule#1#2addreplacementrule@#1@nil#2
defaddreplacementrule@#1#2@nil#3%
 ri@activecharsexpandaftertheri@activechars\#1%
 ri@maketransitions#2@nil#1#3%


defreplace#1%
 begingroup
 def\##1%
 bgrouplccode`~=`##1lowercaseegroup
 def~ri@continue##1%
 %
 catcode`##1=active
 %
 theri@activechars
 scantokens#1%
 endgroup


defri@maketransitions#1#2@nil#3#4%
 deftemp#2%
 ifxtempempty
 expandafterdefcsname ri@lookup@detokenize#3#1endcsname#4%
 letnextrelax
 else
 expandafterdefcsname ri@lookup@detokenize#3#1endcsnameri@continue#3#1%
 defnextri@maketransitions#2@nil#3#1#4%
 fi
 next



defri@continue#1#2%
 @ifundefinedri@lookup@detokenize#1#2%
 detokenize#1#2% 
 %
 csname ri@lookup@detokenize#1#2endcsname
 %



begindocument
addreplacementrulex[2]x_2
addreplacementrulex[3]x^2

$x+1+x[2]+x[3]+x[1]$

replace$x+1+x[2]+x[3]+x[1]$
enddocument