user26743: I am at the moment working with an Arduino Uno, and am struggling to understand how I perform 32-bit arithmetic using it.
The expression I have to calculate is this: √(2 n/a) in which n is an integer and a constant float. 
I am at all not sure how I should do this so any advise would be helpful here. 

user-1: Since you are using floats and need more than a quick approximation, I would recommend one of the following methods:
The Babylonian method
Digit-by-Digit
The first is a fast approximation with a known bound on the error, the second will give a known exact result but with more computation steps in general. Both obviously round to the precision of your data type. 
EDIT:
For really fast computations check out the crazy fast inverse square root
of the first algorithm on this page.
Disclaimer: I have never had to implement a square root like this, but I've done others like Sine(x). 
EDIT 2: @pipe made a good point. If you just want it to work, use sqrt(x) 

user7508: You wrote:

the 16 most significant should be accurate.

Are you absolutely sure about that? Please reconsider. It is easy, when
asking a question, to ask for something better than what you strictly
need... until you realize the cost of fulfilling those expectations.
I have been working recently on a fixed-point implementation of the
square root. It is meant to work with numbers in [0, 1) represented in
0.16 format, i.e. unsigned, 0 bits integer part, 16 bits
fractional part. It is based on the polynomial approximation
√x ≈ 0.1908901 + 1.5392302 x − 1.4475870 x2
+ 1.0217778 x3 − 0.3043110 x4
which is quite good for x ∈ [0.25, 1]. Numbers in (0, 0.25) can be
moved to that interval by successive multiplications by 4, and then
dividing the result by 2. In other words, by using the fact that
√x = √(4 x) / 2
The maximum error is 2.56e-4, i.e. 16.8 ulps (units in the last
place). It takes 298 CPU cycles to execute in the worst case. Note
that, in order to achieve this performance, I had to implement the
multiplication in assembly. Otherwise gcc would give me inefficient
code.
Here is the code:
/*
 * Convert x to a 16-bit fixed point number
 * with n bits after the binary point.
 */
#define FIXED(x, n) ((uint16_t)((float)(x) * (1UL << (n)) + .5))

/*
 * Fixed point multiplication.
 *
 * Multiply two fixed point numbers in unsigned 0.16 format.
 * Returns result in the same format.
 * Rounds to nearest, ties rounded up.
 */
static uint16_t mul_fix_u16(uint16_t x, uint16_t y)
{
    uint16_t result;
#if defined(__AVR_HAVE_MUL__) && defined(__AVR_HAVE_MOVW__)
    /* Optimized ASM version. */
    asm volatile(
        "mul  %B1, %B2\n\t"
        "movw %A0, r0\n\t"
        "ldi  r19, 0x80\n\t"
        "clr  r18\n\t"
        "mul  %A1, %A2\n\t"
        "add  r19, r1\n\t"
        "adc  %A0, r18\n\t"
        "adc  %B0, r18\n\t"
        "mul  %B1, %A2\n\t"
        "add  r19, r0\n\t"
        "adc  %A0, r1\n\t"
        "adc  %B0, r18\n\t"
        "mul  %A1, %B2\n\t"
        "add  r19, r0\n\t"
        "adc  %A0, r1\n\t"
        "adc  %B0, r18\n\t"
        "clr  r1"
        : "=&r" (result)
        : "r" (x), "r" (y)
        : "r18", "r19"
    );
#else
    /* Generic C version. Compiles to inefficient 32 bit code. */
    result = ((uint32_t) x * y + 0x8000) >> 16;
#endif
    return result;
}

/*
 * Fixed point square root.
 * Argument and result in unsigned 0.16 format.
 *
 * If defined(REALLY_ACCURATE):
 *   max error = 7.67e-6
 *   execution time:
 *     937   cycles (worst case)
 *     828.1 cycles (average)
 * else
 *   max error = 2.56e-4
 *   execution time:
 *     298   cycles (worst case)
 *     184.7 cycles (average)
 */
uint16_t sqrt_fix(uint16_t x)
{
    if (x == 0) return 0;
    uint8_t n;
#ifdef REALLY_ACCURATE
    if (x == 0xffff) return 0xffff;
    uint16_t x0 = x;
#endif
    for (n = 0; x < 0x4000; n++) x <<= 2;  // scale the operand
    uint16_t y;
    y = FIXED(0.30435, 15);
    y = FIXED(1.02173, 15) - mul_fix_u16(x, y);
    y = FIXED(1.44754, 15) - mul_fix_u16(x, y);
    y = FIXED(1.53925, 15) - mul_fix_u16(x, y);
    y = FIXED(0.19089, 16) + (mul_fix_u16(x, y) << 1);
    while (n--) y >>= 1;                   // scale the result
#ifdef REALLY_ACCURATE
    y = (y + ((uint32_t)x0 << 16) / y + 1) / 2;  // Babylonian iteration
#endif
    return y;
}

If you really need a very accurate result, you can
#define REALLY_ACCURATE. This will add a single iteration of the
Babylonian method, which is essentially Newton's method applied to
the square root:
y ← (y + x/y) / 2
where y is our approximation of √x. This looks like an easy win:
just a division, an addition and a bit shift. And it makes the result
practically perfect, with a maximum error of 7.67e-6 (0.502 ulps).
But the execution time is increased more than threefold, at
937 cycles in the worst case. This is because the AVR chip has no
hardware support for division, and the software alternative provided by
the compiler is awfully slow.

26743: <p>I am at the moment working with an Arduino Uno, and am struggling to understand how I perform 32-bit arithmetic using it.</p>

<p>The expression I have to calculate is this: &#8730;(2 n/a) in which <code>n</code> is an integer and <code>a</code> constant float. </p>

<p>I am at all not sure how I should do this so any advise would be helpful here. </p>
 -1: <p>Since you are using floats and need more than a quick approximation, I would recommend one of the following methods:</p>

<p><a href="https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method" rel="nofollow noreferrer">The Babylonian method</a></p>

<p><a href="https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Digit-by-digit_calculation" rel="nofollow noreferrer">Digit-by-Digit</a></p>

<p>The first is a fast approximation with a known bound on the error, the second will give a known exact result but with more computation steps in general. Both obviously round to the precision of your data type. </p>

<p>EDIT:</p>

<p>For really fast computations check out the crazy <a href="https://en.wikipedia.org/wiki/Fast_inverse_square_root" rel="nofollow noreferrer">fast inverse square root</a></p>

<p>of the first algorithm on <a href="https://stackoverflow.com/questions/19611198/finding-square-root-without-using-sqrt-function">this page</a>.
Disclaimer: I have never had to implement a square root like this, but I've done others like Sine(x). </p>

<p>EDIT 2: @pipe made a good point. If you just want it to work, use <a href="https://www.arduino.cc/en/Reference/Sqrt" rel="nofollow noreferrer">sqrt(x)</a> </p>
 7508: <p>You wrote:</p>

<blockquote>
  <p>the 16 most significant should be accurate.</p>
</blockquote>

<p>Are you absolutely sure about that? Please reconsider. It is easy, when
asking a question, to ask for something better than what you strictly
need... until you realize the cost of fulfilling those expectations.</p>

<p>I have been working recently on a fixed-point implementation of the
square root. It is meant to work with numbers in [0, 1) represented in
0.16&nbsp;format, i.e. unsigned, 0&nbsp;bits integer part, 16&nbsp;bits
fractional part. It is based on the polynomial approximation</p>

<p>√<em>x</em> ≈ 0.1908901 + 1.5392302 <em>x</em> − 1.4475870 <em>x</em><sup>2</sup>
+ 1.0217778 <em>x</em><sup>3</sup> − 0.3043110 <em>x</em><sup>4</sup></p>

<p>which is quite good for <em>x</em> ∈ [0.25, 1]. Numbers in (0, 0.25) can be
moved to that interval by successive multiplications by 4, and then
dividing the result by 2. In other words, by using the fact that</p>

<p>√<em>x</em> = √(4 <em>x</em>) / 2</p>

<p>The maximum error is 2.56e-4, i.e. 16.8&nbsp;ulps (units in the last
place). It takes 298&nbsp;CPU cycles to execute in the worst case. Note
that, in order to achieve this performance, I had to implement the
multiplication in assembly. Otherwise gcc would give me inefficient
code.</p>

<p>Here is the code:</p>

<pre class="lang-c prettyprint-override"><code>/*
 * Convert x to a 16-bit fixed point number
 * with n bits after the binary point.
 */
#define FIXED(x, n) ((uint16_t)((float)(x) * (1UL &lt;&lt; (n)) + .5))

/*
 * Fixed point multiplication.
 *
 * Multiply two fixed point numbers in unsigned 0.16 format.
 * Returns result in the same format.
 * Rounds to nearest, ties rounded up.
 */
static uint16_t mul_fix_u16(uint16_t x, uint16_t y)
{
    uint16_t result;
#if defined(__AVR_HAVE_MUL__) &amp;&amp; defined(__AVR_HAVE_MOVW__)
    /* Optimized ASM version. */
    asm volatile(
        "mul  %B1, %B2\n\t"
        "movw %A0, r0\n\t"
        "ldi  r19, 0x80\n\t"
        "clr  r18\n\t"
        "mul  %A1, %A2\n\t"
        "add  r19, r1\n\t"
        "adc  %A0, r18\n\t"
        "adc  %B0, r18\n\t"
        "mul  %B1, %A2\n\t"
        "add  r19, r0\n\t"
        "adc  %A0, r1\n\t"
        "adc  %B0, r18\n\t"
        "mul  %A1, %B2\n\t"
        "add  r19, r0\n\t"
        "adc  %A0, r1\n\t"
        "adc  %B0, r18\n\t"
        "clr  r1"
        : "=&amp;r" (result)
        : "r" (x), "r" (y)
        : "r18", "r19"
    );
#else
    /* Generic C version. Compiles to inefficient 32 bit code. */
    result = ((uint32_t) x * y + 0x8000) &gt;&gt; 16;
#endif
    return result;
}

/*
 * Fixed point square root.
 * Argument and result in unsigned 0.16 format.
 *
 * If defined(REALLY_ACCURATE):
 *   max error = 7.67e-6
 *   execution time:
 *     937   cycles (worst case)
 *     828.1 cycles (average)
 * else
 *   max error = 2.56e-4
 *   execution time:
 *     298   cycles (worst case)
 *     184.7 cycles (average)
 */
uint16_t sqrt_fix(uint16_t x)
{
    if (x == 0) return 0;
    uint8_t n;
#ifdef REALLY_ACCURATE
    if (x == 0xffff) return 0xffff;
    uint16_t x0 = x;
#endif
    for (n = 0; x &lt; 0x4000; n++) x &lt;&lt;= 2;  // scale the operand
    uint16_t y;
    y = FIXED(0.30435, 15);
    y = FIXED(1.02173, 15) - mul_fix_u16(x, y);
    y = FIXED(1.44754, 15) - mul_fix_u16(x, y);
    y = FIXED(1.53925, 15) - mul_fix_u16(x, y);
    y = FIXED(0.19089, 16) + (mul_fix_u16(x, y) &lt;&lt; 1);
    while (n--) y &gt;&gt;= 1;                   // scale the result
#ifdef REALLY_ACCURATE
    y = (y + ((uint32_t)x0 &lt;&lt; 16) / y + 1) / 2;  // Babylonian iteration
#endif
    return y;
}
</code></pre>

<p>If you really need a very accurate result, you can
<code>#define REALLY_ACCURATE</code>. This will add a single iteration of the
<a href="https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method" rel="nofollow">Babylonian method</a>, which is essentially Newton's method applied to
the square root:</p>

<p><em>y</em> ← (<em>y</em> + <em>x</em>/<em>y</em>) / 2</p>

<p>where <em>y</em> is our approximation of √<em>x</em>. This looks like an easy win:
just a division, an addition and a bit shift. And it makes the result
practically perfect, with a maximum error of 7.67e-6 (0.502&nbsp;ulps).
But the execution time is increased more than threefold, at
937&nbsp;cycles in the worst case. This is because the AVR chip has no
hardware support for division, and the software alternative provided by
the compiler is awfully slow.</p>
