Skip to main content

programming - How to construct custom operators with precedence?


I need to combine data structures in operations analogous to addition, subtraction, multiplication and division (and more). I need more than one operation of each type, i.e. more than one method of addition, subtraction, etc. I have made some progress. Using the Notation palette, i can for example define !/! and %/% as different operators for division. But how can I set precedence? My impression is that this is not possible. I have explored the existing symbols without in-built meanings, such as CirclePlus and CircleMinus. These symbols without in-built meanings have precedence while allowing the meaning to be defined by the user. But I can't find enough of them to meet my needs. For example, there is no "CircleDivide".


Might it be possible to use subscripts and have $/_a$ and $/_b$ for different types of division while retaining the precedence of the division operator? If I could do it for division, then I could do it for the other operators of interest too.


ADDENDUM: I've made some progress following the clue provided by Mr.Wizard. The following code creates subscripted operators for operations analogous to +,-,*,/. The conv functions are highly simplified for test purposes and in the actual application would perform operations on data structures.


In[1]:= conv[x_, y_, op_ /; op == "+" || op == "-"] := Module[{},
If[op == "-", Return[conv[x, -y, "+"]]]; x + y]


conv[x_, y_, op_ /; op == "*" || op == "/"] := Module[{},
If[op == "/", Return[conv[x, 1/y, "*"]]]; x y]

MakeExpression[RowBox[{x_, SubscriptBox["+", "i"], y_}], StandardForm] :=
MakeExpression[RowBox[{"conv", "[", x, ",", y, ",", "\"+\"", "]"}], StandardForm]
MakeExpression[RowBox[{x_, SubscriptBox["-", "i"], y_}], StandardForm] :=
MakeExpression[RowBox[{"conv", "[", x, ",", y, ",", "\"-\"", "]"}], StandardForm]
MakeExpression[RowBox[{x_, SubscriptBox["*", "i"], y_}], StandardForm] :=
MakeExpression[RowBox[{"conv", "[", x, ",", y, ",", "\"*\"", "]"}], StandardForm]

MakeExpression[RowBox[{x_, SubscriptBox["/", "i"], y_}], StandardForm] :=
MakeExpression[RowBox[{"conv", "[", x, ",", y, ",", "\"/\"", "]"}], StandardForm]

Testing the code, it works at least up to a point and the subscripted operators appear to have the same precedence as the parent operators (+,*, etc.):


test 1


However, if I remove the parentheses from the second test expression, I get an error message. Why is that occurring and how do I fix it?


test 2



Answer



The construction of custom operators with precedence is described in the Complex Patterns and Advanced Features Notation Package Tutorial. More general informations can be found in Precedence of Operators in Notations.


The following operator definitions work for the examples given in the question.

First loading the Notation Package:


Needs["Notation`"]

Now I'll add an InputAlias for each operator, although this increases the convenience only for $-_i$ significantly.


AddInputAlias["+i" -> ParsedBoxWrapper[SubscriptBox["+", "i"]]]

AddInputAlias["*i" -> ParsedBoxWrapper[SubscriptBox["*", "i"]]]

AddInputAlias["/i" -> ParsedBoxWrapper[SubscriptBox["/", "i"]]]


AddInputAlias["-i" -> ParsedBoxWrapper[
TagBox[SubscriptBox["-", "i"], Minus, SyntaxForm -> "a"]]]

Using the Notation Palette this looks like AddInputAlias First I'll define the infix operators with some not yet defined functions


InfixNotation[ParsedBoxWrapper[SubscriptBox["+", "i"]], myPlus]

InfixNotation[ParsedBoxWrapper[SubscriptBox["*", "i"]], myTimes]

InfixNotation[ParsedBoxWrapper[SubscriptBox["/", "i"]], myDivision]


InfixNotation[ParsedBoxWrapper[
TagBox[SubscriptBox["-", "i"], Minus, SyntaxForm -> "a"]], myMinus]

InfixNotation


For a first test, your testing code in a copyable format


\!\(\(9 \*TagBox[SubscriptBox["-", "i"],Minus,SyntaxForm->"a"] 2\*SubscriptBox[\(*\), \(i\)]3\)\*SubscriptBox[\(+\), \(i\)]\(4\*SubscriptBox[\(/\), \(i\)]2\)\)

\!\(4\*SubscriptBox[\(+\), \(i\)]\(6\*SubscriptBox[\(*\), \(i\)]2\*SubscriptBox[\(/\), \(i\)]4\)\)

which can be easily typed in using the InputAliases or the Subscript keyboard shortcut (Ctrl+_) for the ones without a TagBox and will look (together with their output) like



Test1


The output of the first test example nicely shows the correct parenthesization.


Finally the placeholder functions are defined as


myPlus = Plus;
myMinus[a_, b_] := Plus[a, Times[-1, b]]
myTimes[a_, b_] := Times[a, b]
myDivision = Divide;

and the examples tested again


\!\(\(9 \*TagBox[SubscriptBox["-", "i"],Minus,SyntaxForm->"a"] 2 \*SubscriptBox[\(*\), \(i\)]3\)\*SubscriptBox[\(+\), \(i\)]\(4 \*SubscriptBox[\(/\), \(i\)]2\)\)


\!\(4\*SubscriptBox[\(+\), \(i\)]\(6\*SubscriptBox[\(*\), \(i\)]2 \*SubscriptBox[\(/\), \(i\)]4\)\)

\!\(\((9 \*TagBox[SubscriptBox["-", "i"],Minus,SyntaxForm->"a"] 2 \*SubscriptBox[\(*\), \(i\)]3)\)\*SubscriptBox[\(+\), \(i\)]\(4 \*SubscriptBox[\(/\), \(i\)]2\)\)

Test2


As described in the tutorials linked to at the beginning of this answer, the SyntaxForm option of TagBox can be used to change the precedence of an operator. For the given examples this is only needed for $-_i$, because for the other operators it is determined by their corresponding operators without a subscript. For $-_i$ the precedence has to be changed, because otherwise everything following $-_i$ is parenthesized as one part. Using SyntaxForm -> "a" the precedence behavior is "group as a symbol".


Just to illustrate the wrong parenthesization, when the precedence behavior is "group as infix minus operator":


ClearAll[myPlus, myPlus, myDivision, myMinus]
RemoveInfixNotation[ParsedBoxWrapper[

TagBox[SubscriptBox["-", "i"], Minus, SyntaxForm -> "a"]], myMinus]

InfixNotation[ParsedBoxWrapper[
TagBox[SubscriptBox["-", "i"], Minus, SyntaxForm -> "a-b"]], myMinus]

\!\(9\*TagBox[SubscriptBox["-", "i"],Minus,SyntaxForm->"a-b"]\(2\*SubscriptBox[\(*\), \(i\)]3\)\*SubscriptBox[\(+\), \(i\)]\(4\*SubscriptBox[\(/\), \(i\)]2\)\)

wrongParenthesization


Comments

Popular posts from this blog

mathematical optimization - Minimizing using indices, error: Part::pkspec1: The expression cannot be used as a part specification

I want to use Minimize where the variables to minimize are indices pointing into an array. Here a MWE that hopefully shows what my problem is. vars = u@# & /@ Range[3]; cons = Flatten@ { Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; Minimize[{Total@((vec1[[#]] - vec2[[u[#]]])^2 & /@ Range[1, 3]), cons}, vars, Integers] The error I get: Part::pkspec1: The expression u[1] cannot be used as a part specification. >> Answer Ok, it seems that one can get around Mathematica trying to evaluate vec2[[u[1]]] too early by using the function Indexed[vec2,u[1]] . The working MWE would then look like the following: vars = u@# & /@ Range[3]; cons = Flatten@{ Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; NMinimize[ {Total@((vec1[[#]] - Indexed[vec2, u[#]])^2 & /@ R...

functions - Get leading series expansion term?

Given a function f[x] , I would like to have a function leadingSeries that returns just the leading term in the series around x=0 . For example: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x)] x and leadingSeries[(1/x + 2 + (1 - 1/x^3)/4)/(4 + x)] -(1/(16 x^3)) Is there such a function in Mathematica? Or maybe one can implement it efficiently? EDIT I finally went with the following implementation, based on Carl Woll 's answer: lds[ex_,x_]:=( (ex/.x->(x+O[x]^2))/.SeriesData[U_,Z_,L_List,Mi_,Ma_,De_]:>SeriesData[U,Z,{L[[1]]},Mi,Mi+1,De]//Quiet//Normal) The advantage is, that this one also properly works with functions whose leading term is a constant: lds[Exp[x],x] 1 Answer Update 1 Updated to eliminate SeriesData and to not return additional terms Perhaps you could use: leadingSeries[expr_, x_] := Normal[expr /. x->(x+O[x]^2) /. a_List :> Take[a, 1]] Then for your examples: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x), x] leadingSeries[Exp[x], x] leadingSeries[(1/x + 2 + (1 - 1/x...

What is and isn't a valid variable specification for Manipulate?

I have an expression whose terms have arguments (representing subscripts), like this: myExpr = A[0] + V[1,T] I would like to put it inside a Manipulate to see its value as I move around the parameters. (The goal is eventually to plot it wrt one of the variables inside.) However, Mathematica complains when I set V[1,T] as a manipulated variable: Manipulate[Evaluate[myExpr], {A[0], 0, 1}, {V[1, T], 0, 1}] (*Manipulate::vsform: Manipulate argument {V[1,T],0,1} does not have the correct form for a variable specification. >> *) As a workaround, if I get rid of the symbol T inside the argument, it works fine: Manipulate[ Evaluate[myExpr /. T -> 15], {A[0], 0, 1}, {V[1, 15], 0, 1}] Why this behavior? Can anyone point me to the documentation that says what counts as a valid variable? And is there a way to get Manpiulate to accept an expression with a symbolic argument as a variable? Investigations I've done so far: I tried using variableQ from this answer , but it says V[1...