Hcfyk

This is a slightly different question to what I've seen before, where I can use something like newcommand{ga}{gamma} 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

newcommand{x[2]}{x_2}

and

newcommand{a[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:

documentclass{article}

usepackage{amsmath}

usepackage{xparse}



ExplSyntaxOn

NewDocumentCommand{trans}{m}

 {

  tl_set:Nn l__brad_trans_tl { #1 }

  regex_replace_all:nnN { [(.*?)] } { c{sb}cB{1cE} } l__brad_trans_tl

  regex_replace_all:nnN { a } { c{alpha} } l__brad_trans_tl

  % other replacements

  % ...

  % deliver the new token list

  l__brad_trans_tl

 }

ExplSyntaxOff



begin{document}



$trans{x[1]+x[2]^2+a+a[3]}$



end{document}

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

documentclass{article}



begin{document}





mathcode`[="8000

mathcode`]="8000

{

catcode`[=active gdef[{_bgroup}

catcode`]=active gdef]{egroup}

}



hmmm

[

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

]



end{document}

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.

documentclass{article}

usepackage{listofitems}

newtokseqtoks

newcommandaddtoeqtoks[1]{expandaftereqtoksexpandafter{theeqtoks#1}}

newcommandtranslate[1]{%

  setsepchar{[||]}%

  readlistmyeqn{#1}%

  eqtoks{}%

  foreachitemxinmyeqn{%

    ifnumxcnt=1else%

      if[myeqnsep[numexprxcnt-1]addtoeqtoks{_bgroup}fi%

      if]myeqnsep[numexprxcnt-1]addtoeqtoks{egroup}fi%

    fi%

    expandafteraddtoeqtoksexpandafter{x}%

  }%

  theeqtoks%

}

begin{document}

[

translate{a[1]+a[2]+b[c+d[3]] + x}

]

end{document}

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 frac{alpha +beta }{sqrt{gamma }} with no need to tweak the output.

Here's a solution. The command addreplacementrule{text-to-replace}{replacement-text} specifies replacements to make. Then the command replace{some math} does the replacements.

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

documentclass{article}

makeatletter

newtoksri@activechars

defaddreplacementrule#1#2{addreplacementrule@#1@nil{#2}}

defaddreplacementrule@#1#2@nil#3{%

    ri@activecharsexpandafter{theri@activechars\#1}%

    ri@maketransitions#2@nil{#1}{#3}%

}



defreplace#1{%

    begingroup

    def\##1{%

        bgrouplccode`~=`##1lowercase{egroup

            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#1}endcsname{#4}%

        letnextrelax

    else

        expandafterdefcsname ri@lookup@detokenize{#3#1}endcsname{ri@continue{#3#1}}%

        defnext{ri@maketransitions#2@nil{#3#1}{#4}}%

    fi

    next

}





defri@continue#1#2{%

    @ifundefined{ri@lookup@detokenize{#1#2}}{%

        detokenize{#1}#2%  

    }{%

        csname ri@lookup@detokenize{#1#2}endcsname

    }%

}





begin{document}

addreplacementrule{x[2]}{x_2}

addreplacementrule{x[3]}{x^2}



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



replace{$x+1+x[2]+x[3]+x[1]$}

end{document}

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.

documentclass{article}

usepackage{luacode} % for "luacode" environment and "luastringN" macro

begin{luacode}

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

end{luacode}



%% TeX-side code

newcommandtrans[1]{directlua{trans(luastringN{#1})}}



begin{document}

$trans{x[1]+x[2]^2+a+a[3]}$



$trans{a[1]+a[2]+b[c+d[3]]+x}$

end{document}