    # Sample from the vector &#39;a&#39; 1 element.
    sample(a, 1)

the above answers are technically correct:

    sample(a, 1)

however, if you would like to repeat this process many times, let&#39;s say you would like to imitate throwing a dice, then you need to add:

    a &lt;- c(1,2,3,4,5,6)
    sample(a, 12, replace=TRUE)

Hope it helps.

**Be careful when using sample!**   

`sample(a, 1)` works great for the vector in your example, but when the vector has length 1 it may lead to undesired behavior, it will use the vector `1:a` for the sampling.

So if you are trying to pick a random item from a varying length vector, check for the case of length 1!

    sampleWithoutSurprises &lt;- function(x) {
      if (length(x) &lt;= 1) {
        return(x)
      } else {
        return(sample(x,1))
      }
    }



This method doesn&#39;t produce an error when your vector is length one, and it&#39;s simple.

    a[sample(1:length(a), 1)]

Read [this][1] article about generating random numbers in R.

http://blog.revolutionanalytics.com/2009/02/how-to-choose-a-random-number-in-r.html

You can use `sample` in this case

    sample(a, 1)
    
Second attribute is showing that you want to get only **one** random number.
To generate number between some range `runif` function is useful.


  [1]: http://blog.revolutionanalytics.com/2009/02/how-to-choose-a-random-number-in-r.html

An alternative is to select an item from the vector using runif. i.e

    a &lt;- c(1,2,0,7,5)
    a[runif(1,1,6)]

Lets say you want a function that picks one each time it is run (useful in a simulation for example). So

    a &lt;- c(1,2,0,7,5)
    sample_fun_a &lt;- function() sample(a, 1)
    runif_fun_a &lt;- function() a[runif(1,1,6)]
    microbenchmark::microbenchmark(sample_fun_a(), 
                               runif_fun_a(),
                               times = 100000L)

Unit: nanoseconds

sample_fun_a() - 4665

runif_fun_a() - 1400 

runif seems to be quicker in this example.



Using Django templating engine I can include another partial template while setting a custom context using named arguments, like this:

    {% include &quot;list.html&quot; with articles=articles_list1 only %}
    {% include &quot;list.html&quot; with articles=articles_list2 only %}

As you may be supposing, `articles_list1` and `articles_list2` are two different lists, but I can reuse the very same `list.html` template which will be using the `articles` variable.

I&#39;m trying to achieve the same thing using Jinja2, but I can&#39;t see what&#39;s the recommended way, as the `with` keyword is not supported.

How to pass selected, named arguments to Jinja2&#39;s include context?

I&#39;m having issues getting a block of code to run properly. I&#39;m not entirely sure WHAT this code does (I&#39;m trying to get a plugin that&#39;s out of date to work properly with our server), I just know every 20 minutes it runs and throws out an error. Here&#39;s the section of code where the issue is happening:

    public class DynamicThread extends Thread {
    private LocalShops plugin = null;


    public DynamicThread(ThreadGroup tgroup, String tname, LocalShops plugin) {
        super(tgroup, tname);
        this.plugin = plugin;
    }

    public void run() {
        Map&lt;ItemInfo, List&lt;Integer&gt;&gt; itemStockMap = Collections.synchronizedMap(new HashMap&lt;ItemInfo, List&lt;Integer&gt;&gt;());
        
        //Dump all the shop stock data into the map.
        for ( Shop shop : plugin.getShopManager().getAllShops() ) {
            for ( InventoryItem item : shop.getItems() ) {
                if (itemStockMap.containsKey(item.getInfo()))
                    itemStockMap.get(item.getInfo()).add(item.getStock()); //Where error happens
                else
                    itemStockMap.put(item.getInfo(), Arrays.asList(item.getStock()));     
            }
        }
        for(ItemInfo item : itemStockMap.keySet()) {
            List&lt;Integer&gt; stockList = GenericFunctions.limitOutliers(itemStockMap.get(item));
            //remove the map before re-adding it
            if (DynamicManager.getPriceAdjMap().containsKey(item)) 
                DynamicManager.getPriceAdjMap().remove(item);
            
            //Get the overall stock change for a given item and then calculate the adjustment given the volatility
            int deltaStock = GenericFunctions.getSum(stockList) - Config.getGlobalBaseStock();
            DynamicManager.getPriceAdjMap().put(item, GenericFunctions.getAdjustment(Config.getGlobalVolatility(), deltaStock)); 
        }
        
        Bukkit.getServer().getScheduler().callSyncMethod(plugin, plugin.getShopManager().updateSigns());
    }

}


The error happens from line 42, which is:

                    itemStockMap.get(item.getInfo()).add(item.getStock());

The error it outputs happens every 20 minutes twice with 2 seconds in between.

    2012-02-16 16:53:25 [INFO] Launch Dynamic Thread
    2012-02-16 16:53:25 [SEVERE] Exception in thread &quot;dynamic&quot; 
    2012-02-16 16:53:25 [SEVERE] java.lang.UnsupportedOperationException
    2012-02-16 16:53:25 [SEVERE] at java.util.AbstractList.add(AbstractList.java:131)
    2012-02-16 16:53:25 [SEVERE] at java.util.AbstractList.add(AbstractList.java:91)
    2012-02-16 16:53:25 [SEVERE] at       com.milkbukkit.localshops.threads.DynamicThread.run(DynamicThread.java:42)

    2012-02-16 16:53:27 [INFO] Launch Dynamic Thread
    2012-02-16 16:53:27 [SEVERE] Exception in thread &quot;dynamic&quot; 
    2012-02-16 16:53:27 [SEVERE] java.lang.UnsupportedOperationException
    2012-02-16 16:53:27 [SEVERE] at java.util.AbstractList.add(AbstractList.java:131)
    2012-02-16 16:53:27 [SEVERE] at java.util.AbstractList.add(AbstractList.java:91)
    2012-02-16 16:53:27 [SEVERE] at     com.milkbukkit.localshops.threads.DynamicThread.run(DynamicThread.java:42)


Thanks in advance for any help. 

UnsupportedOperationException at java.util.AbstractList.add

    a&lt;-c(1,2,0,7,5)

Some languages have a picker -function -- choose one random number from `a` -- how in R?

Select random element in a list of R?

<pre><code class="hljs language-scss">a&#x3C;-c(1,2,0,7,5)
</code></pre>
Some languages have a picker -function -- choose one random number from <code>a</code> -- how in R?

Can I force R to use regular numbers instead of using the `e+10`-like notation? I have:

    1.810032e+09
    # and 
    4

within the same vector and want to see: 

    1810032000
    # and
    4

I am creating output for an old fashioned program and I have to write a text file using `cat`. 
That works fine so far but I simply can&#39;t use the `e+10` notation there.



Force R not to use exponential notation (e.g. e+10)?

How to check if entire vector has no values other than NA (or NAN) in R ?

If I use is.na it returns a vector of TRUE / FALSE.

I need to check if there is single not NA element or not.

How to check if entire vector has no values other than NA (or NAN) in R?

*EDIT: Hadley Wickham points out that I misspoke. R CMD check is throwing NOTES, not Warnings. I&#39;m terribly sorry for the confusion. It was my oversight.*

## The short version

`R CMD check` throws this note every time I use [sensible plot-creation syntax][4] in ggplot2:

    no visible binding for global variable [variable name]

I understand why R CMD check does that, but it seems to be criminalizing an entire vein of otherwise sensible syntax. I&#39;m not sure what steps to take to get my package to pass `R CMD check` and get admitted to CRAN.

## The background

Sascha Epskamp previously posted on [essentially the same issue][1]. The difference, I think, is that `subset()`&#39;s manpage [says it&#39;s designed for interactive use][2].

In my case, the issue is not over `subset()` but over a core feature of `ggplot2`: the `data =` argument.

## An example of code I write that generates these notes

Here&#39;s [a sub-function][4] in [my package][3] that adds points to a plot:

    JitteredResponsesByContrast &lt;- function (data) {
      return(
        geom_point(
                 aes(
                   x = x.values, 
                   y = y.values
                 ),
                 data     = data,
                 position = position_jitter(height = 0, width = GetDegreeOfJitter(jj))
        )
      )
    }

`R CMD check`, on parsing this code, will say

    granovagg.contr : JitteredResponsesByContrast: no visible binding for
      global variable &#39;x.values&#39;
    granovagg.contr : JitteredResponsesByContrast: no visible binding for
      global variable &#39;y.values&#39;


## Why R CMD check is right

The check is technically correct. `x.values` and `y.values`

* Aren&#39;t defined locally in the function `JitteredResponsesByContrast()`
* Aren&#39;t pre-defined in the form `x.values &lt;- [something]` either globally or in the caller.

Instead, they&#39;re variables within a dataframe that gets defined earlier and passed into the function `JitteredResponsesByContrast()`.

## Why ggplot2 makes it difficult to appease R CMD check

ggplot2 seems to encourage the use of a `data` argument. The data argument, presumably, is why this code will execute

    library(ggplot2)
    p &lt;- ggplot(aes(x = hwy, y = cty), data = mpg)
    p + geom_point()
    
but **this** code will produce an object-not-found error:

    library(ggplot2)
    hwy # a variable in the mpg dataset

## Two work-arounds, and why I&#39;m happy with neither

### The NULLing out strategy

[Matthew Dowle recommends][6] setting the problematic variables to NULL first, which in my case would look like this:

    JitteredResponsesByContrast &lt;- function (data) {
      x.values &lt;- y.values &lt;- NULL # Setting the variables to NULL first
      return(
        geom_point(
                 aes(
                   x = x.values, 
                   y = y.values
                 ),
                 data     = data,
                 position = position_jitter(height = 0, width = GetDegreeOfJitter(jj))
        )
      )
    }

I appreciate this solution, but I dislike it for three reasons. 

1. it serves no additional purpose beyond appeasing `R CMD check`.
2. it doesn&#39;t reflect intent. It raises the expectation that the `aes()` call will see our now-NULL variables (it won&#39;t), while obscuring the real purpose (making R CMD check aware of variables it apparently wouldn&#39;t otherwise know were bound)
3. The problems of 1 and 2 multiply because every time you write a function that returns a plot element, you have to add a confusing NULLing statement

### The with() strategy

You can use `with()` to explicitly signal that the variables in question can be found inside some larger environment. In my case, using `with()` looks like this:

    JitteredResponsesByContrast &lt;- function (data) {
      with(data, {
          geom_point(
                   aes(
                     x = x.values, 
                     y = y.values
                   ),
                   data     = data,
                   position = position_jitter(height = 0, width = GetDegreeOfJitter(jj))
          )
        }
      )
    }

This solution works. But, I don&#39;t like this solution because it doesn&#39;t even work the way I would expect it to. If `with()` were really solving the problem of pointing the interpreter to where the variables are, then I shouldn&#39;t even *need* the `data =` argument. But, `with()` doesn&#39;t work that way:

    library(ggplot2)
    p &lt;- ggplot()
    p &lt;- p + with(mpg, geom_point(aes(x = hwy, y = cty)))
    p # will generate an error saying `hwy` is not found
    
So, again, I think this solution has similar flaws to the NULLing strategy:

1. I still have to go through every plot element function and wrap the logic in a `with()` call
2. The `with()` call is misleading. I still need to supply a `data =` argument; all `with()` is doing is appeasing `R CMD check`.

## Conclusion

The way I see it, there are three options I could take:

1. Lobby CRAN to ignore the notes by arguing that they&#39;re &quot;spurious&quot; (pursuant to [CRAN policy][5]), and do that every time I submit a package
2. Fix my code with one of two undesirable strategies (NULLing or `with()` blocks)
3. Hum really loudly and hope the problem goes away

None of the three make me happy, and I&#39;m wondering what people suggest I (and other package developers wanting to tap into ggplot2) should do. 

[1]: https://stackoverflow.com/questions/8096313/no-visible-binding-for-global-variable-note-in-r-cmd-check
[2]: https://stackoverflow.com/questions/8096313/no-visible-binding-for-global-variable-note-in-r-cmd-check/8096456#8096456
[3]: https://github.com/briandk/granovaGG
[4]:  https://github.com/briandk/granovaGG/blob/dev/R/granovagg.contr.R#L254-265
[5]: http://cran.r-project.org/web/packages/policies.html#Submission
[6]: https://stackoverflow.com/a/8096882/180626






How can I handle R CMD check &quot;no visible binding for global variable&quot; notes when my ggplot2 syntax is sensible?

I have a matrix (2601 by 58) of particulate matter concentration estimates from an air quality model.  Because real-life air quality monitors cannot measure below 0.1 ug/L, I need to replace all values in my matrix that are `&lt;0.1` with a zero/NA/null value. 

Someone suggested `ifelse(test, true, false)` with a logical statement, but when I try this it deletes everything.

Replace all values in a matrix &lt;0.1 with 0

For example, how would I go about entering the value e^2 in R?

Content Type	Original Author	Original Content on Stackoverflow
Question	hhh	View Question on Stackoverflow
Solution 1 - R	Dason	View Answer on Stackoverflow
Solution 2 - R	moldovean	View Answer on Stackoverflow
Solution 3 - R	pomber	View Answer on Stackoverflow
Solution 4 - R	skan	View Answer on Stackoverflow
Solution 5 - R	Chuck Norris	View Answer on Stackoverflow
Solution 6 - R	MrHopko	View Answer on Stackoverflow

Select random element in a list of R?

R Problem Overview

R Solutions

Solution 1 - R

Solution 2 - R

Solution 3 - R

Solution 4 - R

Solution 5 - R

Solution 6 - R

UnsupportedOperationException at java.util.AbstractList.add

How to pass selected, named arguments to Jinja2's include context?

Attributions