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

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

How to thread a list

I have data in format data = {{a1, a2}, {b1, b2}, {c1, c2}, {d1, d2}} Tableform: I want to thread it to : tdata = {{{a1, b1}, {a2, b2}}, {{a1, c1}, {a2, c2}}, {{a1, d1}, {a2, d2}}} Tableform: And I would like to do better then pseudofunction[n_] := Transpose[{data2[[1]], data2[[n]]}]; SetAttributes[pseudofunction, Listable]; Range[2, 4] // pseudofunction Here is my benchmark data, where data3 is normal sample of real data. data3 = Drop[ExcelWorkBook[[Column1 ;; Column4]], None, 1]; data2 = {a #, b #, c #, d #} & /@ Range[1, 10^5]; data = RandomReal[{0, 1}, {10^6, 4}]; Here is my benchmark code kptnw[list_] := Transpose[{Table[First@#, {Length@# - 1}], Rest@#}, {3, 1, 2}] &@list kptnw2[list_] := Transpose[{ConstantArray[First@#, Length@# - 1], Rest@#}, {3, 1, 2}] &@list OleksandrR[list_] := Flatten[Outer[List, List@First[list], Rest[list], 1], {{2}, {1, 4}}] paradox2[list_] := Partition[Riffle[list[[1]], #], 2] & /@ Drop[list, 1] RM[list_] := FoldList[Transpose[{First@li...

front end - keyboard shortcut to invoke Insert new matrix

I frequently need to type in some matrices, and the menu command Insert > Table/Matrix > New... allows matrices with lines drawn between columns and rows, which is very helpful. I would like to make a keyboard shortcut for it, but cannot find the relevant frontend token command (4209405) for it. Since the FullForm[] and InputForm[] of matrices with lines drawn between rows and columns is the same as those without lines, it's hard to do this via 3rd party system-wide text expanders (e.g. autohotkey or atext on mac). How does one assign a keyboard shortcut for the menu item Insert > Table/Matrix > New... , preferably using only mathematica? Thanks! Answer In the MenuSetup.tr (for linux located in the $InstallationDirectory/SystemFiles/FrontEnd/TextResources/X/ directory), I changed the line MenuItem["&New...", "CreateGridBoxDialog"] to read MenuItem["&New...", "CreateGridBoxDialog", MenuKey["m", Modifiers-...