Skip to main content

plotting - improving sequence dot operator for matrix rows and plot of Norm-imaginary


I have written a code to Dot a row (conjugate of that) of mm to the next one:


mm={{1,2,I},{I,I,3},{2,6,I},{1,6,4},{1,4,5}}

fIdD = ConstantArray[0, {Dimensions[mm][[1]] - 1, 2}];

Do[

fIdD[[j]][[1]] = j;
fIdD[[j]][[2]] = Dot[mm[[j]]\[Conjugate], mm[[j + 1]]]

, {j, 1, Dimensions[mm][[1]] - 1}];

Is there any possibility to use of mathematica syntax instead of this code for this aim(dot a conjugated row to the next one).


fIdD={{1, 0}, {2, -5 I}, {3, 38 - 4 I}, {4, 45}}


And if I am going to plot the {{1,Norm[0]},{2,Norm[-5I]},{3,Norm[38-4I]},{4,Norm[45]}} with the ListPlot. same as this: however it is wrong: ListPlot[{#1, Norm[ #2]}, & fIdD]?!



Answer



I would simply do


Dot[Conjugate[#1], #2] & @@@ Partition[mm, 2, 1]

and do away with the sequential numbers, as those are easy enough to generate when needed any way (MapIndexed?) ListPlot does not need these indices.


But instead of jumping straight to the solution, let's take your code and improve it step by step.




  1. Instead of arr[[i]][[j]] you can write arr[[i,j]]. This is simpler and more readable.





  2. You are pre-initializing an array of known dimensions and then compute each element. This is never necessary in Mathematica. This is what Table is for.


    At this point we have


    Table[
    {j, Conjugate[mm[[j]]].mm[[j + 1]]},
    {j, 1, Dimensions[mm][[1]] - 1}
    ]

    Much simper than the original code.



    Additionally, Dimensions[mm][[1]] is simpler and clearer as Length[mm].




  3. When you use the iterator in Table to index an array, there are usually simpler ways. Instead of Table[ f[ arr[[i]] ], {i, 1, Length[arr]}] we can always write Table[f[elem], {elem, arr}].


    But here you need to iterate through consecutive pairs of elements, not each element. Partition can make a list of pairs (or tuples) from a simple list. Partition[{a,b,c,d}, 2] would give {{a,b}, {c,d}} while Partition[{a,b,c,d}, 2, 1] will give {{a,b}, {b,c}, {c,d}. This latter is what you need.


    This changes our code to


    Table[
    Conjugate[elem[[1]]].elem[[2]],
    {elem, Partition[mm, 2, 1]}
    ]


    Instead of elem[[1]] people often write First[elem], which might be more readable, depending on context. Since we have a list of pairs, in this particular case elem[[2]] would be Last[elem].


    You might rightly argue that this change is not really a simplification, and it also loses the integer index form the result. But it leads up to the next step.




  4. When we have a list of the form list = {{x1,y1}, {x2,y2}, ..., {xn,yn}}, and we need to transform it to {f[x1,y1], f[x2,y2], ..., f[xn,yn]}, one pattern I like to use is


    f @@@ list

    This is short for Apply[f, list, {1}], please look up Apply. If we already have a pre-defined function f, this makes for very simple and clear code. If we don't, we can construct f on the fly as a pure function.


    This gives us the final version:



    result = Dot[Conjugate[#1], #2] & @@@ Partition[mm, 2, 1]

    One reason why I like this style is that I find #1 much more readable than elem[[1]]. Too many brackets give me a headache :-)




To re-insert the integer indices, you can use


Transpose[{Range@Length[result], result}]

But in applications that need the index of each element, MapIndexed can be useful too. MapIndexed[{First[#2], #1} &, result] is another way to get the result, though I'd integrate MapIndexed with the step that ultimately uses these indices.


ListPlot does not need these indices, it automatically assumes x coordinates to be 1, 2, ... if they're not given. So plotting is as simple as



ListPlot[ Norm /@ result ]

f /@ list is short for Map[f, list], please look up Map.




As you can see, Mathematica has many ways to do the same thing, and it's up to you to choose one. I hope you found this little introduction educational.


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...