Tag Info

Hot answers tagged

24

Preamble This is a very good question, because answering it will make it very clear what immutability means, both in general and in the context of Associations. General A few general words on immutability Associations are immutable data structures. This means that they carry no state, and a copy of an Association is another completely independent ...


19

I hesitate to add anything after @Leonid's comprehensive answer, but I'd like to point out that an easy way to achieve the stated goal is to define f like this: f[x_] := <| x, "isFirstValueTrue" -> x@"firstValue" |> ... which yields the desired result when mapped across the associations in x: f /@ x (* { <|"firstValue" -> True, ...


15

These three functions are similar (speaking commonly), and in some applications any of them could be used, yet they have very different special applications. Rudimentarily: Map wraps (sub)expressions in a given Head, and returns the modified input Apply replaces Heads in (sub)expressions, and returns the modified input Scan "visits" (sub)expressions, ...


12

Use Map with a levelspec of {-1}: Map[g, {a, b, {c, d}, {{e}}}, {-1}] {g[a],g[b],{g[c],g[d]},{{g[e]}}}


11

This perhaps: Function[{a, b}, a[#]/b[#] &] @@@ {{a, b}, {c, d}, {e, f}} (* Out: {a[#1]/b[#1] &, c[#1]/d[#1] &, e[#1]/f[#1] &} *) Mr.Wizard's way of writing it (see comment) looks like this in the frontend:


11

When experimenting with Map (do check the examples under this link), it's better not to define the function you're mapping. If it's not defined, it won't evaluate and it's easier to see what's going on. Map[f, 1+x] is Map[f, Plus[1,x]] with a different notation. So you get Plus[f[1], f[x]], i.e. f[1]+f[2]. Map[f, x] returns x because x is an atomic ...


10

What you have is a so called linked list, and such lists are usually traversed through recursion like this: applyFunc[f_, {el_, rest_}, level_: {1}] := {f[el, level], applyFunc[f, rest, Prepend[level, 2]]} applyFunc[f_, {el_}, level_] := {f[el, level]} applyFunc[h, expr] {h[a, {1}], {h[b, {2, 1}], {h[c^d, {2, 2, 1}], {h[e + f g, {2, 2, 2,1}]}}}} But ...


10

Interesting question. Here is my proposal: fn[f_, expr_] := Module[{h}, h[x_List, _] := x; h[o_[x__h], i_] := h[o @@ {x}[[All, 1]], i]; MapIndexed[h, expr, {1, -1}] /. h -> f ] Test: fn[h, {a, q Sqrt[r], {{{e + f g h}, c^d}, b}}] {h[a, {1}], h[q Sqrt[r], {2}], {{{h[e + f g h, {3, 1, 1, 1}]}, h[c^d, {3, 1, 2}]}, h[b, {3, 2}]}} I ...


9

May be this is not the smarter way to do it but here is what I got: l = {a, {b, {c^d, {e + f g}}}}; pos = ReplaceAll[(Position[l, List]), 0 -> 1]; h[l[[Sequence @@ #]], #] & /@ pos (*{h[a, {1}], h[b, {2, 1}], h[c^d, {2, 2, 1}], h[e + f g, {2, 2, 2, 1}]}*) If you want to keep the levels as they are then: rule = Rule[#, h[l[[Sequence @@ #]], #]] ...


8

MapThread[Thread[{##}] &, {lst2, lst1}] Map[Thread, {lst2, lst1}\[Transpose]] ## is used so Thread gets called like Thread[{1, {a, b, c}}] As MapThread gives two arguments in this case it is equivalent to Thread[{#1, #2}]& and Composition[Thread, List]


8

If you look at SystemOptions[], like so, Column[ OpenerView /@ (Replace[SystemOptions[], Rule[x_, y_] -> List[x, y], 1]) ] you see that under CompileOptions, if you click on the triangle to open it, there is an option "MapCompileLength" -> 100. Set it to eg 10 and see it it helps (do SetSystemOptions["CompileOptions" -> ...


7

I would use the following, Quiet[ Check[ PowerMod[#, -1, 126] + #, ##&[], PowerMod::ninv ]& /@ Range[125], PowerMod::ninv ] (* {2, 106, 34, 110, 106, 92, 34, 146, 142, 92, 146, 124, 128, 106, 160, 110, 106, 92, 160, 146, 142, 92, 146, 124, 128, 106, 160, 110, 106, 218, 160, 146, 142, 218, 146, 250} *) where ##&[] inserts a ...


7

Here is one way: movingMapCircular[f_, l_List] := MapThread[f@* List, {l, RotateLeft[l]}]; For example: movingMapCircular[f, {1, 2, 3, 4}] (* {f[{1, 2}], f[{2, 3}], f[{3, 4}], f[{4, 1}]} *) A generalization of this approach for arbitrary window size may look like: ClearAll[movingMapCircular]; movingMapCircular[f_, l_List, {n_Integer}] := MapThread[ ...


7

"Reflected" padding works as desired but "Periodic" padding is missed. There is corresponding definition for "Reflected" RandomProcesses`TemporalDataUtilitiesDump`toCannonicalPadding[ RandomProcesses`TemporalDataUtilitiesDump`td_, "Reflected", RandomProcesses`TemporalDataUtilitiesDump`w_, RandomProcesses`TemporalDataUtilitiesDump`Caller_] := ...


6

molekyla777's answer can be very helpful but it is not technically correct. The question specifies "every element of a list" but using a levelspec of {-1} will apply the function to every atomic element regardless of its head: Map[f, 1 + 5 x + 10 x^2 + 10 x^3, {-1}] f[1] + f[5] f[x] + f[10] f[x]^f[2] + f[10] f[x]^f[3] Of course this can be very ...


6

Very similar to ssch's second answer, but sometimes Thread feels more natural than Transpose: Thread /@ Thread @ {lst2, lst1} Less clear, but more interesting, is to make a Listable version of List: Function[, {##}, Listable][lst2, lst1] You could also use my smartThread function: smartThread @ {lst2, lst1}


6

A Map/MapThread-less solution Transpose@Inner[List, lst2, lst1, List]


6

ReplacePart If one is willing to bend on the requirement to use MapIndexed, ReplacePart can generate the desired output directly: $list = {a, {b, {c^d, {e + f g}}}}; ReplacePart[$list, {i:PatternSequence[2..., 1]} :> h[$list[[i]], {i}]] (* {h[a, {1}], {h[b, {2, 1}], {h[c^d, {2, 2, 1}], {h[e + f g, {2, 2, 2, 1}]}}}} *) MapIndexed Alternatively, we ...


6

Here is a way to use MapThread: MapThread[Function[{r, s}, r + # & /@ s], {tensorR, tensorS}, 2] For numeric tensors, it can be compiled to squeeze out a little more performance: Compile[{{tensorR, _Real, 3}, {tensorS, _Real, 4}} , MapThread[Function[{r, s}, r + # & /@ s], {tensorR, tensorS}, 2] ] Performance Measurements @kguler's solution ...


6

First, your construction of f is a bit malformed. You are using the operator form of Select, therefore the Select expression itself acts as a function; you do not need to add @# & to it. Use instead: f = Select[#[[2]] >= 10 &]; The reason that your operations are not the same can be seen by mapping a dummy function foo: foo /@ a <|1 ...


6

Since version 9 you do not need to do anything extra. tab1 = {{a1, a1 + a2}, {b1, b2*b2}} tab2 = {{2, 5}, {5, 2}} Solve[tab1 == tab2] {{a2 -> 3, b1 -> 5, a1 -> 2, b2 -> -Sqrt[2]}, {a2 -> 3, b1 -> 5, a1 -> 2, b2 -> Sqrt[2]}}


5

Edit You had an error in the transcription of the equation for y[t]: a = 8.0; d = 0.2; g = 0.4; m = 15; s = 0.4; data = RecurrenceTable[{x[0] == 17, y[0] == 30, x[t] == (1. - a s) x[t - 1] + a (s m + (g*(s m/d - y[t - 1])) + ArcTan[x[t - 1] - m]), y[t] == (1. - d) y[t - 1] + s m + g*(s m/d - y[t - 1]) + ArcTan[x[t - 1] - m]}, {x, y}, {t, 0, ...


5

Here's a way to write out the map concisely: Q1: {1 - #, ##2} Through[Join[{1 &}, f]@#] & @@@ A (* {{1 - a1, b1 f1[a1], c1 f2[a1], d1 f3[a1], e1 f4[a1]}, {1 - a2, b2 f1[a2], c2 f2[a2], d2 f3[a2], e2 f4[a2]}, {1 - a3, b3 f1[a3], c3 f2[a3], d3 f3[a3], e3 f4[a3]}} *) Q2: Join[{1 - #[[1]]}, MapThread[#3 #@#2 &, {f, Most@#, Rest@#}]] ...


5

Here are two ways to do it. data = {{1, 3, 5}, {4, 5, 1}, {4, 9, 2}}; Replace[data, {a_, b_, c_} :> {a, b, f[b, c]}, {1}] {{1, 3, f[3, 5]}, {4, 5, f[5, 1]}, {4, 9, f[9, 2]}} MapThread[{#1, #2, f[#2, #3]} &, data] {{1, 3, f[3, 5]}, {4, 5, f[5, 1]}, {4, 9, f[9, 2]}} A small variant of the last is MapThread[{#1, #2, f[##2]} &, data]


5

When the sublists are short like in your example, I tend to use Apply: {#1, #2, f[#2, #3]}& @@@ {{1, 3, 5}, {4, 5, 1}, {4, 9, 2}}


5

You can almost always turn to replacement patterns when you need to transform expressions: Cases[ {{a, b}, {c, d}, {e, f}}, {x_, y_} :> (x[#]/y[#] &) ] {a[#1]/b[#1] &, c[#1]/d[#1] &, e[#1]/f[#1] &} Cases defaults to levelspec {1} so this is safer than using /..


5

In your first example, Map maps the function f over Plus, applying f to each argument. In the second case this is not possible, because there is just an x. What is your expected result? Maybe this? Map[f, {x}] (* {2 x} *)


5

fileNames = "file" <> # & /@ RandomSample[CharacterRange["A", "Z"], 4] (* {"fileS","fileU","fileJ","fileO"} *) sheetNames = "sheet" <> # & /@ # & /@ (RandomSample[CharacterRange["A", "Z"], RandomInteger[{1, 3}]] & /@ Range[4]) (* ...


5

A method using a single Plot expression: myFunc[x_, y_] := Sin[x y] yvalues = {0.1, 0.5, 1.0, 2.0, 3.0}; Block[{x}, Plot[#, {x, -5, 5}, PlotRange -> All, PlotLegends -> Automatic] &[ If[Cos[#] <= x <= 0 || 0 <= x <= Cos[#], myFunc[x, #]] & /@ yvalues ] ] Notes: I use Block to keep x localized. I did not programmatically ...


5

Another method with a single plot: ClearAll[myFunc2]; yvalues = {0.1`, 0.5`, 1.`, 2.`, 3.`}; myFunc2[x_?NumericQ, y_?NumericQ] := ConditionalExpression[Sin[x y], IntervalMemberQ[Interval[{0, Cos[y]}], x]]; {min, max} = Through[{Min, Max}[Cos[yvalues]]]; Plot[myFunc2[x, #] & /@ yvalues, {x, min, max}, Evaluated -> True, BaseStyle -> ...



Only top voted, non community-wiki answers of a minimum length are eligible