Question: I am dealing with a site with the following structure

```
<div class="col-3"
  <field-input>
     <div class=" group-4">
         <input> #Lets call this input 1 </input>
  <field-input>
     <div class=" group-4">
         <input> #Lets call this input 2 </input>

```

I want to pass in values to `input field 1` and `input field 2`. How could I do this? I tried the following and it gives me an error saying 

> 
> cannot find elements
> 
> 
> 

```
driver.find_element(:xpath, "//field-input/div/input").send_keys("myvalue")

```

How could I do this?

Answer: 
The `NumericMatrix` class is provided by `Rcpp`, so you need to access it either by pulling in the Rcpp namespace with

```
using namespace Rcpp;

```

or explicitly prefix the namespace name, e.g.

```
Rcpp::NumericMatrix

```

Note that the warning re: avoiding use of the R / Rcpp API implies avoiding their use within the definition of your `RcppParallel::Worker` functions. The over-arching reason you want to avoid using the R / Rcpp API within a parallel context is that these routines may:

1. Allocate, and hence trigger the R garbage collector, which will cause big problems if done on a separate thread; or
2. Throw an error, and hence cause a `longjmp` that blows up the universe (which, if I understand correctly, is a permissible consequence of undefined behavior in a C++ program)

You can typically construct your `Worker` object from `Rcpp` objects, but to be safe you generally want to store the associated data with a local `RcppParallel::RMatrix<T>` object, as that object is 'safer' in that it only provides routines that are safe to use in a parallel context -- in particular, it provides iterators that allow you to use it with the C++ STL, which should be sufficient in many scenarios.
```
#include <RcppParallel.h>
using namespace RcppParallel;

```

**Patch your code with the below lines instead of the above lines in your code. You haven't included the Rcpp name space and this worked for me.**

```
// [[Rcpp::depends(RcppParallel)]]
#include <Rcpp.h>
#include <RcppParallel.h>
using namespace Rcpp;
using namespace RcppParallel;

```

You haven't pulled the Rcpp namespace, that will be needed during the compilation of the space NumericVector or NumericMatrix.

**So, the working code will be**

```
// [[Rcpp::depends(RcppParallel)]]
#include <Rcpp.h>
#include <RcppParallel.h>
#include <limits>
using namespace Rcpp;
using namespace RcppParallel;
struct SquareRoot : public Worker
{
// source matrix
 const RMatrix<double> input;

// destination matrix
RMatrix<double> output;

// initialize with source and destination
 SquareRoot(const NumericMatrix input, NumericMatrix output) 
 : input(input), output(output) {}

// take the square root of the range of elements requested
 void operator()(std::size_t begin, std::size_t end) {
 std::transform(input.begin() + begin, 
               input.begin() + end, 
               output.begin() + begin, 
               ::sqrt);
 }
 };

  // [[Rcpp::export]]
   NumericMatrix parallelMatrixSqrt(NumericMatrix x) {

  // allocate the output matrix
   NumericMatrix output(x.nrow(), x.ncol());

  // SquareRoot functor (pass input and output matrixes)
   SquareRoot squareRoot(x, output);

  // call parallelFor to do the work
    parallelFor(0, x.length(), squareRoot);

  // return the output matrix
  return output;
  }

```

However, I get the error for "no matching function to call for transform", If you know the answer may be, kindly reply.