xsl-list
[Top] [All Lists]
<prev [Date] next>
[Advanced]
 <prev [Thread] next>

Re: [xsl] How to Do Random "Shuffle"?

2014-09-13 11:44:40
from [Dimitre Novatchev dnovatchev(_at_)gmail(_dot_)com] [Permanent Link] 
One will need just that from the provided full test:

    RandomizeList:
    <xsl:call-template name="randomizeList">
      <xsl:with-param name="pList" select="/*/*"/>
    </xsl:call-template>

On Sat, Sep 13, 2014 at 9:39 AM, Dimitre Novatchev 
<dnovatchev(_at_)gmail(_dot_)com> wrote:

This can be done even with XSLT 1.0:

http://fxsl.sourceforge.net/articles/Random/Casting%20the%20Dice%20with%20FXSL-htm.htm

More specifically, use the FXSL 1 stylesheet module randomList.xsl

Here is an existing test (demo):

When this transformation (testRandomList.xsl):

<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform";
 xmlns:ext="http://exslt.org/common";
 xmlns:f="http://fxsl.sf.net/";
 xmlns:mySquare="f:mySquare"
 xmlns:myDouble="f:myDouble"
 exclude-result-prefixes="xsl f ext mySquare myDouble"
 >

  <xsl:import href="randomList.xsl"/>

  <xsl:output omit-xml-declaration="yes" indent="yes"/>
   <!-- This transformation must be applied to:
        numList.xml
     -->

  <mySquare:mySquare/>
  <myDouble:myDouble/>

  <xsl:template match="/">

    <xsl:variable name="vrtfRands">
      <xsl:call-template name="randomSequence">
        <xsl:with-param name="pLength" select="100"/>
      </xsl:call-template>
    </xsl:variable>

    Random Recursive Index (dScale (randomSequence 100)):

    <xsl:call-template name="_dScale">
      <xsl:with-param name="pRandSeq"
          select="ext:node-set($vrtfRands)/*"/>
    </xsl:call-template>

    Random Recursive Index 10:

    <xsl:variable name="vrtfRecIndex">
      <xsl:call-template name="_randomRecursiveIndex">
        <xsl:with-param name="pList"
        select="/*/*"/>
      </xsl:call-template>
    </xsl:variable>

    <xsl:variable name="vRecIndex"
              select="ext:node-set($vrtfRecIndex)/*"/>

    <xsl:for-each select="$vRecIndex">
      <xsl:copy-of select="."/>&#xA;
    </xsl:for-each>

    Randomized 10-elements list:
    <xsl:call-template name="_permutationFromRecursiveIndex">
      <xsl:with-param name="pList" select="/*/*"/>
      <xsl:with-param name="pRecIndex" select="$vRecIndex"/>
    </xsl:call-template>

    RandomizeList:
    <xsl:call-template name="randomizeList">
      <xsl:with-param name="pList" select="/*/*"/>
    </xsl:call-template>

    <xsl:variable name="vFunSquare"
         select="document('')/*/mySquare:*[1]"/>

    _mapFromRandIndex (^2) [1..10] seed:
    <xsl:call-template name="_mapFromRandIndex">
      <xsl:with-param name="pFun" select="$vFunSquare"/>
      <xsl:with-param name="pList" select="/*/*"/>
      <xsl:with-param name="pRecIndex" select="$vRecIndex"/>
    </xsl:call-template>

    <xsl:variable name="vFunDouble"
         select="document('')/*/myDouble:*[1]"/>

    randomMap (*2) [1..10] seed:
    <xsl:call-template name="randomMap">
      <xsl:with-param name="pFun" select="$vFunDouble"/>
      <xsl:with-param name="pList" select="/*/*"/>
    </xsl:call-template>

    randListIndex [1..10] seed:
    <xsl:call-template name="randListIndex">
      <xsl:with-param name="pList" select="/*/*"/>
    </xsl:call-template>

  </xsl:template>

  <xsl:template match="mySquare:*" mode="f:FXSL">
    <xsl:param name="arg1"/>

    <xsl:value-of select="$arg1 * $arg1"/>
  </xsl:template>
  <xsl:template match="myDouble:*" mode="f:FXSL">
    <xsl:param name="arg1"/>

    <xsl:value-of select="$arg1 + $arg1"/>
  </xsl:template>
</xsl:stylesheet>

is applied on this source XML document:

<nums>
  <num>01</num>
  <num>02</num>
  <num>03</num>
  <num>04</num>
  <num>05</num>
  <num>06</num>
  <num>07</num>
  <num>08</num>
  <num>09</num>
  <num>10</num>
</nums>

the result is:



    Random Recursive Index (dScale (randomSequence 100)):

    <el>27</el>
<el>90</el>
<el>14</el>
<el>78</el>
<el>65</el>
<el>13</el>
<el>27</el>
<el>85</el>
<el>75</el>
<el>33</el>
<el>31</el>
<el>26</el>
<el>9</el>
<el>40</el>
<el>31</el>
<el>80</el>
<el>19</el>
<el>44</el>
<el>52</el>
<el>7</el>
<el>8</el>
<el>73</el>
<el>55</el>
<el>16</el>
<el>68</el>
<el>20</el>
<el>29</el>
<el>4</el>
<el>3</el>
<el>30</el>
<el>51</el>
<el>41</el>
<el>14</el>
<el>32</el>
<el>66</el>
<el>4</el>
<el>19</el>
<el>51</el>
<el>48</el>
<el>59</el>
<el>30</el>
<el>1</el>
<el>49</el>
<el>57</el>
<el>14</el>
<el>53</el>
<el>13</el>
<el>10</el>
<el>10</el>
<el>38</el>
<el>13</el>
<el>37</el>
<el>13</el>
<el>36</el>
<el>22</el>
<el>7</el>
<el>28</el>
<el>25</el>
<el>28</el>
<el>7</el>
<el>29</el>
<el>3</el>
<el>34</el>
<el>28</el>
<el>7</el>
<el>13</el>
<el>14</el>
<el>5</el>
<el>32</el>
<el>25</el>
<el>25</el>
<el>24</el>
<el>8</el>
<el>26</el>
<el>23</el>
<el>14</el>
<el>11</el>
<el>18</el>
<el>15</el>
<el>6</el>
<el>5</el>
<el>6</el>
<el>9</el>
<el>4</el>
<el>8</el>
<el>14</el>
<el>12</el>
<el>12</el>
<el>5</el>
<el>2</el>
<el>5</el>
<el>1</el>
<el>4</el>
<el>1</el>
<el>4</el>
<el>4</el>
<el>1</el>
<el>2</el>
<el>1</el>
<el>1</el>

    Random Recursive Index 10:

    <el>3</el>
<el>9</el>
<el>2</el>
<el>6</el>
<el>5</el>
<el>1</el>
<el>2</el>
<el>3</el>
<el>2</el>
<el>1</el>

    Randomized 10-elements list:
    <el>03</el>
<el>10</el>
<el>02</el>
<el>08</el>
<el>07</el>
<el>01</el>
<el>05</el>
<el>09</el>
<el>06</el>
<el>04</el>

    RandomizeList:
    <el>03</el>
<el>10</el>
<el>02</el>
<el>08</el>
<el>07</el>
<el>01</el>
<el>05</el>
<el>09</el>
<el>06</el>
<el>04</el>

    _mapFromRandIndex (^2) [1..10] seed:
    <el>9</el>
<el>100</el>
<el>4</el>
<el>64</el>
<el>49</el>
<el>1</el>
<el>25</el>
<el>81</el>
<el>36</el>
<el>16</el>

    randomMap (*2) [1..10] seed:
    <el>6</el>
<el>20</el>
<el>4</el>
<el>16</el>
<el>14</el>
<el>2</el>
<el>10</el>
<el>18</el>
<el>12</el>
<el>8</el>

    randListIndex [1..10] seed:
    <el>3</el>
<el>10</el>
<el>2</el>
<el>8</el>
<el>7</el>
<el>1</el>
<el>5</el>
<el>9</el>
<el>6</el>
<el>4</el>

The last result gives us a random index of the integers in [1, 10]

These indexes can be used to select in a random order 10 nodes.

In XSLT 2 one can use the standard XPath function current-time() for
the creation of the seed:
http://www.w3.org/TR/xpath-functions/#func-current-time

Cheers,
Dimitre



On Sat, Sep 13, 2014 at 7:29 AM, Eliot Kimber ekimber(_at_)contrext(_dot_)com
<xsl-list-service(_at_)lists(_dot_)mulberrytech(_dot_)com> wrote:

Using XSLT 2 I need to implement rendering of "match table" questions
where you have two sets of items, the match item and the thing it matches
to. I want to present this as a literal table, where the first column is
the match-from items in source order and the second column is the match-to
items, in random order.

I think this is best characterized as a "shuffle" problem, where you want
to reorder a list randomly but all items in the list must be accounted
for.

I can think of a recursive algorithm: given a list, generate a random
integer between 1 and the list length, select that item and add it to the
result list, then call this function on the original list minus the node
you just selected.

Is there an easier or more efficient way to do it?

Thanks,

Eliot
—————
Eliot Kimber, Owner
Contrext, LLC
http://contrext.com






-- 
Cheers,
Dimitre Novatchev
---------------------------------------
Truly great madness cannot be achieved without significant intelligence.
---------------------------------------
To invent, you need a good imagination and a pile of junk
-------------------------------------
Never fight an inanimate object
-------------------------------------
To avoid situations in which you might make mistakes may be the
biggest mistake of all
------------------------------------
Quality means doing it right when no one is looking.
-------------------------------------
You've achieved success in your field when you don't know whether what
you're doing is work or play
-------------------------------------
To achieve the impossible dream, try going to sleep.
-------------------------------------
Facts do not cease to exist because they are ignored.
-------------------------------------
Typing monkeys will write all Shakespeare's works in 200yrs.Will they
write all patents, too? :)
-------------------------------------
I finally figured out the only reason to be alive is to enjoy it.
--~----------------------------------------------------------------
XSL-List info and archive: http://www.mulberrytech.com/xsl/xsl-list
EasyUnsubscribe: http://lists.mulberrytech.com/unsub/xsl-list/1167547
or by email: xsl-list-unsub(_at_)lists(_dot_)mulberrytech(_dot_)com
--~--
[More with this subject...]
<Prev in Thread] Current Thread [Next in Thread>
Previous by Date:  Re: [xsl] How to Do Random "Shuffle"?, Dimitre Novatchev dnovatchev(_at_)gmail(_dot_)com
Next by Date:  Re: [xsl] How to Do Random "Shuffle"?, Dimitre Novatchev dnovatchev(_at_)gmail(_dot_)com
Previous by Thread:  Re: [xsl] How to Do Random "Shuffle"?, Dimitre Novatchev dnovatchev(_at_)gmail(_dot_)com
Next by Thread:  Re: [xsl] How to Do Random "Shuffle"?, David Rudel fwqhgads(_at_)gmail(_dot_)com
Indexes:  [Date] [Thread] [Top] [All Lists]