Function that imitates Thread

Question

I am fairly new to mathematica. I was given two lists i.e {x1, x2, x3, x4} and {a,b,c,d} and I had to produce the following:

{x1->a,x2->b,x3->c,x4->d}

What I did was the following:

listToRules =Thread[{x1, x2, x3, x4} -> {a, b, c,d}]

But then I noticed that I was asked to write a function that does this. And I was also asked to write a function RulesTolist[rule1] that extracts and returns the two lists from a substitution list. So is what required different then what I did?

Answer 1

But then I noticed that I was asked to write a function that does this

may be the HW meant not to use Thread? One way could be to write a function like this

L1 = {x1, x2, x3, x4}
L2 = {a, b, c, d}
listToRules[L1_List, L2_List] := Module[{},
  If[Length@L1 != Length@L2, Abort[]];
  (L1[[#]] -> L2[[#]]) & /@ Range[Length@L1]
  ]

Now call it using

listToRules[L1, L2]

If pure functions are not allowed, you can use loop, like this

listToRules[L1_List, L2_List] := Module[{n},
  If[Length@L1 != Length@L2, Abort[]];
  Last@Reap@Do[
     Sow[L1[[n]] -> L2[[n]]], {n, Length@L1}
     ]
  ];
listToRules[L1, L2]

There are many other ways to do this without using Thread

And I was also asked to write a function RulesTolist[rule1]

I assume you mean, given {x1 -> a, x2 -> b, x3 -> c, x4 -> d} you want a function that returns back {{x1, x2, x3, x4},{a, b, c, d}} ? One way could be

rulesTolist[L_List] := Module[{r},
  r = Cases[L, Rule[a_, b_] :> {a, b}];
  {r[[All, 1]], r[[All, 2]]}
  ]

To use it

L = {x1 -> a, x2 -> b, x3 -> c, x4 -> d}
rulesTolist[L]

Mathematica is a very flexible language, and there are many ways to do these things, the above is just one of these ways.

Answer 2

{x1 -> a, x2 -> b, x3 -> c, x4 -> d} // FullForm

List[Rule[x1, a], Rule[x2, b], Rule[x3, c], Rule[x4, d]]

so it's a "matrix"

---

rulesTolist = (# /. Rule -> List // Transpose)&;
{x1 -> a, x2 -> b, x3 -> c, x4 -> d} // rulesTolist

---

Or, use Association

rulesTolist = (# // Association // KeyValueMap[List] // Transpose)&;
{x1 -> a, x2 -> b, x3 -> c, x4 -> d} // rulesTolist

Answer 3

I was asked to write a function that does this

What is probably wanted is something that can be re-used on different inputs. Your variable listToRules is "fixed". Someone would need to assign values to a and x1 and so forth to be able to re-use it. The typical way to do this would look something like this:

makeRules[keys_, values_] := Thread[keys -> values]

And you could use it like this:

makeRules[{x1, x2, x3, x4}, {a, b, c, d}]

{x1 -> a, x2 -> b, x3 -> c, x4 -> d}

But now, you can use it on other inputs:

makeRules[{a, b, c}, {21, 22, 23}]

{a -> 21, b -> 22, c -> 23}

As an aside, this particular function definition isn't very robust, because lists have to satisfy certain criteria for Thread to work, but I doubt that fixing that issue is part of the assignment.

a function RulesTolist[rule1] that extracts and returns the two lists from a substitution list.

Fortunately, Mathematica has some nice, built-in functions for dealing with structures involving Rule, specifically Values and Keys. I think you should try to solve this on your own first, so look in the documentation for those functions. If you need help, show us what you tried. But the pattern you'll use for defining this function will be:

RulesTolist[rules_] := <...figure out what goes here...>

Answer 4

Using Table:

rulesToList[k1_List, k2_List] := 
 Table[k1[[i]] -> k2[[i]], {i, Length@k1}]

xlist = {x1, x2, x3, x4};
vlist = {a, b, c, d};

rulesToList[xlist, vlist]

Using MapThread:

MapThread[Rule, {xlist, vlist}]

Using Transpose:

Rule @@@ Transpose[{xlist, vlist}]

You can convert the last two to functions as an exercise.

---

Result:

{x1 -> a, x2 -> b, x3 -> c, x4 -> d}

Answer 5

Some more ways of doing it in the hopes that it will get you motivated to look up the commands on the documentation

With

vars = {x1, x2, x3, x4};
rules = {a, b, c, d};

We begin by

AssociationThread[vars, #] &@rules // Normal

Another one

GeneralUtilities`AssociatePairs[Transpose[{vars, #}]] &@rules // Normal

Third one

Table[Outer[Rule, vars, rules, 1][[i, i]], {i, 1, 4}]

And another

MapThread[Rule, {vars, #}] &@rules

Final

MapThread[#1 -> #2 &, {vars, #}] &@rules

all of the above return

{x1 -> a, x2 -> b, x3 -> c, x4 -> d}

Answer 6

Inner is another possibility:

Inner[Rule,{x1, x2, x3, x4} , {a, b, c,d},List]

(* {x1 -> a, x2 -> b, x3 -> c, x4 -> d} *) 

Or with Dot:

List@@Rule@@@({x1, x2, x3, x4}.{a, b, c,d})

(* {x1 -> a, x2 -> b, x3 -> c, x4 -> d} *) 

The above is probably better written as:

Composition[Apply[List],MapApply[Rule],Dot][{x1, x2, x3, x4},{a, b, c,d}]

(* {a -> x1, b -> x2, c -> x3, d -> x4} *) 

To get back the original lists from a list of rules:

{#[[All,1]], #[[All,2]]}&@%

{{a, b, c, d}, {x1, x2, x3, x4}}

Answer 7

Just for fun:

rulethread = Block[{Rule}, SetAttributes[Rule, Listable]; #] &;

rulestolist = Block[{Rule = List}, #\[Transpose]] &;

{x1, x2, x3, x4} -> {a, b, c, d} // rulethread
(* {x1 -> a, x2 -> b, x3 -> c, x4 -> d} *)

{x1 -> a, x2 -> b, x3 -> c, x4 -> d} // rulestolist
(* {{x1, x2, x3, x4}, {a, b, c, d}} *)

Answer 8

The assignment is about writing one's first function. We are making this quite more complex than needed.

Mathematica offers two ways to write functions.

function[parameter1_, parameter2_]:=(function of parameter1 and parameter 2)

creates a named function that you can then apply to any parameters that you pass to it when you call it, for example

function[{a,b,c,d},{x1,x2,x3,x4}]

The various answers that offer different listsToRules functions offer solutions on that spirit.

A different type of function that mathematica offers is called a pure function and it uses slots marked by # and must end with &. Then you can apply this pure function on a list with /@, which is the abbreviation for Map. The answers that create a matrix out of the two lists may use this construction, although Syed's Rule@@@Transpose[{xlist, vlist}] skips the step of creating the function and takes advantage of the fact that Rule automatically gets mapped. the more explicit way to do this with a pure function would be

Rule @@ # & /@ Transpose[{xlist, vlist}]

What comes before the /@ gets applied to each member of the transposed matrix of the two lists. The first element, for example, is {x1,a}. The # picks that list up. But Rule@{x1,a} or (the equivalent) Rule[{x1,a}] produces an error because Rule wants two parameters and you are giving it one list as one parameter. The @@ replaces the braces of the list with Rule[] so that the result becomes Rule[x1,a]. I hope this helps. Mathematica is extremely powerful but has a steep learning curve. By the way, this a good time to adopt the formatting convention of never using uppercase for the items you define so as to avoid clashes with built-in symbols. Replace L1 and L2 with list1 and list2.