Question: I have an imported data set that I've used `GroupBy` on to be organized by specific elements of the sublists within the data. These keys are strings of numbers (in particular, they are grouped by day and then by the hour, which is `#[[2, 3]]`, and `#[[2, 4]]` respectively). I am now trying to pick out various keys from these new associations. Here is what a piece of the array looks like:

```
{{string1}, {2016, 3, 4, 0, 0}}

```

So, if I wanted to examine every piece of information from the 4th day of March, I could do `Key["4"]`, which yields:

```
<|"0" -> {{string1}, {2016, 3, 4, 0, 0}} |>

```

I can pick them out individually like this to look at with just the `Key` function, but what I would like to do is pick out several keys to examine a range of days. I've tried using `Keys`, but it doesn't seem to take just a key argument, and going through the whole data set to grab the explicit key values isn't a viable option. Is there an easier way to pick out multiple keys?

Answer: 
Of course in this case you can trust the symbolic result of `Integrate`, but the point raised by the question becomes especially important when there is *no* analytical solution. 

Here is an example suffering from an even more rapid decay that causes the same numerical problems. Finding the right options for `NIntegrate` isn't so obvious:

```
a = 10^6;

integrand = E^(- a w^w );

Integrate[integrand, {w, 0, Infinity}]

(* returns unevaluated because no symbolic solution exists *)

NIntegrate[integrand, {w, 0, Infinity}]

(* ==> 0., with warning message *)

NIntegrate[integrand, {w, 0, Infinity}, Method -> "LocalAdaptive"]

(* ==> 0. *)

```

None of these results are what we want.

What I would suggest is to **try symbolic integration first**, but then automatically fall back to numerical integration if that fails. As explained in the documentation for [`Integrate`](http://reference.wolfram.com/language/ref/Integrate.html) (under "Scope > Basic Usage"), this can be done by simply wrapping `Integrate` in `N`. The advantage for our problem is then that `N` allows a second argument for the desired precision:

```
N[Integrate[integrand, {w, 0, Infinity}], 10]

(* ==> 2.233104982*10^-300622 *)

```

Here, I get a numerical result without having to think about the choice of integration method.
Most of the value of the integral occurs before $w\le 0.00002$.

```
NIntegrate[Exp[-w/a] t, {w, 0, 0.00002}, WorkingPrecision -> 16]

```

> 
> 0.009999999979388476
> 
> 
> 

At `MachinePrecision`, the total value of the integral can be found at $w\le 0.1$.

```
NIntegrate[Exp[-w/a] t , {w, 0, 0.1}]

```

> 
> 0.01
> 
> 
> 

It is therefore not just a question of `MaxRecursion`:

```
NIntegrate[Exp[-w/a] t , {w, 0, \[Infinity]}, MinRecursion -> 10, MaxRecursion -> 30]

```

Provides the answer as well, but Mathematica needs to know that it is not just integrating a horizontal line at zero, after all: $e^{-0.1/a}\approx3.563\*10^{-43430}$.
Hence the error message.

> 
> Integral and error estimates are 0 on all integration subregions. Try increasing the value of the MinRecursion option. If value of integral may be 0, specify a finite value for the AccuracyGoal option. >>
> 
> 
>