[Question]
  [
Given a polynomial function *f* (e.g. as a list *p* of real coefficients in ascending or descending order), a non-negative integer *n*, and a real value *x*, return:
#    *f* n(*x*)
i.e. the value of *f* (*f* (*f* (…*f* (*x*)…))) for *n* applications of *f* on *x*.
Use reasonable precision and rounding.
Solutions that take *f* as a list of coefficients will probably be the most interesting, but if you are able to take *f* as an actual function (thereby reducing this challenge to the trivial "apply a function *n* times"), feel free to include it after your non-trivial solution.
### Example cases
*p* =`[1,0,0]` or *f* =`x^2`, *n* =`0`, *x* =`3`: *f* 0(3) =`3`
*p* =`[1,0,0]` or *f* =`x^2`, *n* =`1`, *x* =`3`: *f* 1(3) =`9`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`0`, *x* =`2.3`: *f* 0(2.3) =`2.3`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`1`, *x* =`2.3`: *f* 1(2.3) =`-8.761`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`2`, *x* =`2.3`: *f* 2(2.3) =`23.8258`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`3`, *x* =`2.3`: *f* 3(2.3) =`-2.03244`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`4`, *x* =`2.3`: *f* 4(2.3) =`1.08768`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`5`, *x* =`2.3`: *f* 5(2.3) =`-6.38336`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`6`, *x* =`2.3`: *f* 6(2.3) =`14.7565`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`7`, *x* =`2.3`: *f* 7(2.3) =`-16.1645`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`8`, *x* =`2.3`: *f* 8(2.3) =`59.3077`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`9`, *x* =`2.3`: *f* 9(2.3) =`211.333`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`10`, *x* =`2.3`: *f* 10(2.3) =`3976.08`
*p* =`[0.1,-2.3,-4]` or *f* =`0.1x^2-2.3x-4`, *n* =`11`, *x* =`2.3`: *f* 11(2.3) =`1571775`
*p* =`[-0.1,2.3,4]` or *f* =`−0.1x^2+2.3x+4`, *n* =`0`, *x* =`-1.1`: *f* 0(-1.1) =`-1.1`
*p* =`[-0.1,2.3,4]` or *f* =`−0.1x^2+2.3x+4`, *n* =`1`, *x* =`-1.1`: *f* 1(-1.1) =`1.349`
*p* =`[-0.1,2.3,4]` or *f* =`−0.1x^2+2.3x+4`, *n* =`2`, *x* =`-1.1`: *f* 2(-1.1) =`6.92072`
*p* =`[-0.1,2.3,4]` or *f* =`−0.1x^2+2.3x+4`, *n* =`14`, *x* =`-1.1`: *f* 14(-1.1) =`15.6131`
*p* =`[0.02,0,0,0,-0.05]` or *f* =`0.02x^4-0.05`, *n* =`25`, *x* =`0.1`: *f* 25(0.1) =`-0.0499999`
*p* =`[0.02,0,-0.01,0,-0.05]` or *f* =`0.02x^4-0.01x^2-0.05`, *n* =`100`, *x* =`0.1`: *f* 100(0.1) =`-0.0500249`
  
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 49 bytes
```
@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQaNAp0InT1MjzdZBo0gnV7PaQUOzQKMIxNY11NTUqaitrsvVNqzV0ASqASr8n5hXrOGgUaFZoRdnpGOsY6T5HwA "Octave – Try It Online")
Or, taking coefficients:
## [Octave](https://www.gnu.org/software/octave/), ~~75~~ 57 bytes
```
@(p,x,n)(f=@(f,n){@()polyval(p,f(f,n-1)),x}{~n+1}())(f,n)
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQaNAp0InT1MjzdZBIw3IqHbQ0CzIz6ksS8wBSqWBxHQNNTV1Kmqr6/K0DWs1NDXB6v4n5hVrRBvqGOkYxAIJY83/AA "Octave – Try It Online")
A special thanks for Suever over at StackOverflow, for [this answer](https://stackoverflow.com/a/36310726/2816870) some time ago on a question of mine, proving that a recursive anonymous function is possible.
This defines an anonymous function, which is a wrapper for a **recursive anonymous function**; something which is not a native Octave concept, and requires some fancy cell array indexing.
As a bonus, the second version is a nice lesson in variable scoping in Octave. All instances of `r` can legally be replaced by `f`, which then simply overwrites the existing `f` in the most local scope (similar for `n`)
### Explanation
```
@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)
@(p,x,n)         .                ..    .  ..   .   % Defines main anonymous function    
        (f=@(r,m).                ..    .  ).   .   % Defines recursive anonymous function
                 .                ..    .   .   .   %  r: Handle ('pointer') to recursive function
                 .                ..    .   .   .   %  m: Current recursion depth (counting from n to 0)
                 .                ..    .   (f,n)   % And call it, with
                 .                ..    .           %  r=f (handle to itself)
                 .                ..    .           %  m=n (initial recursion)
                 {                }{    }           % Create and index into cell array
                                    ~m+1            %  Index: for m>0: 1; for m==0: 2.
                                ,x                  %  Index 2: final recursion, just return x.
                  @()                               %  Index 1: define anonymous function, taking no inputs.
                     p(        )                    %   which evaluates the polynomial 
                       r(     )                     %    of the recursive function call
                         r,m-1                      %     which is called with r 
                                                    %     and recursion depth m-1 
                                                    %     (until m=0, see above)
                                         ()         % Evaluate the result of the cell array indexing operation.
                                                    %  which is either the anonymous function
                                                    %  or the constant `x`.
```
The key to this is that anonymous functions are **not** evaluated when they are defined. So, the `@()`, which seems a bit superfluous since it defines an anonymous function which is called with `()` directly after, is actually strictly necessary. It is not called **unless** it is selected by the indexing statement.
### [Octave](https://www.gnu.org/software/octave/), 39 bytes (boring way)
```
function x=f(p,x,n)for i=1:n;o=p(o);end
```
Just for completeness, the Octave solution with the shortest bytecount.
[Yawn.](https://tio.run/##FYxBCoMwFAX3PcXbFBMIQi3dtAg9QY9QiPrTBuL/YqKNp091MbuZkT7ZlUpxC/fJCyO3Tk0mG9ZOZvj2cueHtJMS/SAeyg7OeMk82hA2g/Ql2E5Wwk@WMKAjeIZF9PwJhHqE84EMooAF1Z5X8BFMPcVo5@2wj0e3Jepl4XRy6qmyzu/GNPXV3HT5Aw "Octave – Try It Online").
[Answer]
# Mathematica, ~~56~~ ~~47~~ 28 bytes
```
Nest[x\[Function]x#+#2&~Fold~#,##2]&
```
`\[Function]` takes 3 bytes in UTF-8.
Take parameters in order `p,x,n`.
`p` (parameter 1) is in increasing order of degree.
Obviously if `f` can be taken as a function this can be reduced just to `Nest`.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
←↓¡`B
```
[Try it online!](https://tio.run/##yygtzv7//1HbhEdtkw8tTHD6//9/tIGeoY6ukZ6xjq5J7H8g/d/QAAA "Husk – Try It Online")
The key idea here is that evaluating a polinomial at a point *x* is equivalent to performing base conversion from base *x*.
`B` when given a base and a list of digits performs base conversion. Here we use its flipped version, in order to take the list of digits first and partially apply this function to it. We obtain then a function which computes the value of the given polynomial at a point, the second part of this solution deals with iterating this function the correct amount of times:
# [Husk](https://github.com/barbuz/Husk), 3 bytes
```
←↓¡
```
`¡` is the "iterate" function, it takes a function and a starting point and returns the infinite list of values obtained iterating the function. 
`↓` takes a number (the third argument of this challenge) and drops that many elements from the start of the list.
`←` returns the first element of the resulting list.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 31 bytes
```
(p,n,x)->for(i=1,n,x=eval(p));x
```
[Try it online!](https://tio.run/##FcfBCoAgDADQX9lxC41N6hT2KYGHDCFsSIR/b3p7T0NJ9tIWwUNDNdlUsnt8CiYvY/78wo1KtNWmJeUXI/LMbqrHYjukww2sBoTZAM9C1H4 "Pari/GP – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 42 bytes
```
->c,n,x{n.times{x=c.reduce{|s,r|s*x+r}};x}
```
C is the list of coefficients in descending order
Trivial version, where f is a lambda function (**26 bytes**):
```
->f,n,x{n.times{x=f[x]};x}
# For example:
# g=->f,n,x{n.times{x=f[x]};x}
# p g[->x{0.02*x**4-0.01*x**2-0.05},100,0.1]
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5ZJ0@nojpPryQzN7W4usI2Wa8oNaU0ObW6plinqKZYq0K7qLbWuqL2f4FCWnS0oY6BjkEskDCO5UIWMIQLGOgZGAHFdIG0IZQ2BcobAJXpGcb@BwA "Ruby – Try It Online")
[Answer]
## JavaScript (ES6), ~~52 49 44~~ 42 bytes
*Saved 5 bytes thanks to [G B](https://codegolf.stackexchange.com/users/18535/g-b) and 2 more bytes thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil)*
Takes input in currying syntax as `(p)(n)(x)`, where ***p*** is the list of coefficients in descending order.
```
p=>n=>g=x=>n--?g(p.reduce((s,v)=>s*x+v)):x
```
### Test cases
```
let f =
p=>n=>g=x=>n--?g(p.reduce((s,v)=>s*x+v)):x
console.log(f([1,0,0])(0)(3))
console.log(f([1,0,0])(1)(3))
console.log(f([0.1,-2.3,-4])(0)(2.3))
console.log(f([0.1,-2.3,-4])(1)(2.3))
console.log(f([0.1,-2.3,-4])(2)(2.3))
console.log(f([0.1,-2.3,-4])(3)(2.3))
console.log(f([0.1,-2.3,-4])(4)(2.3))
console.log(f([0.1,-2.3,-4])(5)(2.3))
console.log(f([0.1,-2.3,-4])(6)(2.3))
console.log(f([0.1,-2.3,-4])(7)(2.3))
console.log(f([0.1,-2.3,-4])(8)(2.3))
console.log(f([0.1,-2.3,-4])(9)(2.3))
console.log(f([0.1,-2.3,-4])(10)(2.3))
console.log(f([0.1,-2.3,-4])(11)(2.3))
console.log(f([-0.1,2.3,4])(0)(-1.1))
console.log(f([-0.1,2.3,4])(1)(-1.1))
console.log(f([-0.1,2.3,4])(2)(-1.1))
console.log(f([-0.1,2.3,4])(14)(-1.1))
console.log(f([0.02,0,0,0,-0.05])(25)(0.1))
console.log(f([0.02,0,-0.01,0,-0.05])(100)(0.1))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
*⁹LḶ¤×⁹Sµ¡
```
[Try it online!](https://tio.run/##y0rNyan8/1/rUeNOn4c7th1acng6kBl8aOuhhf///zfSM/4frWuio6ALZOkoGOgZxv43NAAA "Jelly – Try It Online")
Takes x, coefficients in ascending order, n in this order.
# 4 bytes
```
⁹v$¡
```
[Try it online!](https://tio.run/##y0rNyan8//9R484ylUML////b6Rn/F/p0KbD0/UM4w9PB/JU4k2U/hsaAAA "Jelly – Try It Online")
Takes x, Jelly link (may need to be quoted/escaped), n in this order.
[Answer]
# [J](http://jsoftware.com/), 15 bytes
```
0{(p.{.)^:(]{:)
```
[Try it online!](https://tio.run/##y/r/P03B1krBoFqjQK9aTzPOSiO22kqTiys1OSNfId5EId5Iz1jBQM9QQQMsoZOmqWSoEKsAEtXRU8jUUzA0@v8fAA "J – Try It Online")
Takes the polynomial as a list of coefficients of ascending powers.
## Explanation
```
0{(p.{.)^:(]{:)  Input: polynomial P (LHS), [x, n] (RHS)
            {:   Tail of [x, n], gets n
           ]     Right identity, passes n
  (    )^:       Repeat n times starting with g = [x, n]
     {.            Head of g
   p.              Evaluate P at that value
                   Return g = [P(head(g))]
0{               Return the value at index 0
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~10~~ 9 bytes
-1 byte thanks to [Erik the Outgolfer](https://codegolf.stackexchange.com/users/41024/erik-the-outgolfer)
```
sF³gÝ¨m*O
```
[Try it online!](https://tio.run/##MzBNTDJM/f@/2O3Q5vTDcw@tyNXy///fSM@Yy4QrWtdERxfI1DHQM4wFAA "05AB1E – Try It Online")
Takes x as first argument, n as second and p in ascending order as third.
### Explanation
```
sF³gÝ¨m*O
s         # Forces the top two input arguments to get pushed and swaped on the stack
 F        # Do n times...
  ³        # Push the third input (the coefficients)
   g       # Get the length of that array...
    Ý¨     # and create the range [0 ... length]
      m    # Take the result of the last iteration to these powers (it's just x for the first iteration)
       *   # Multiply the resuling array with the corresponding coefficients
         O # Sum the contents of the array
          # Implicit print
```
[Answer]
# [Haskell](https://www.haskell.org/), 15 bytes
```
((!!).).iterate
```
[Try it online!](https://tio.run/##FcZBCoAgEAXQq/ygxRgoZW3rJBJIaEkWUi48fVO91dvsvbsY2Y@GiapKKKFCdpfNjg8bToxIVzgzaniQKZATqFVdU2YtIEFa9U35Nwh8h@Zn8dGuN8slpRc "Haskell – Try It Online")
Thanks to totallyhuman for 11 bytes off of both solutions
This defines a tacit function that takes a function as its first argument and `n` as its second argument, and composes that function with itself `n` times. This can then be called with an argument `x` to get the final value. Thanks to the magic of currying, this is equivalent to one function taking three arguments.
---
Taking a list of coefficients instead of a function argument:
# [Haskell](https://www.haskell.org/), 53 bytes
```
((!!).).iterate.(\p x->sum$zipWith(*)p[x^i|i<-[0..]])
```
[Try it online!](https://tio.run/##FcbRCsIgFADQX7mDPVwFL8t6bPuNHuYGMrRdckOmgUTfntV5OqtNDxdC9b2piE0jSBBnd9jsCE2Eoob03NoXxxvnFaWIY5n5zVc1dkTTJOpmeYce4sF7hhY8oCmgBsCOTrLMWoAC1HSW5b@LgN9B18/ig72nqpYYvw "Haskell – Try It Online")
This is the same as the above code, but composed with a lambda function that converts a list of coefficients into a polynomial function. The coefficients are taken in reverse order from the examples - as ascending powers of `x`.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~20~~ 9 bytes
```
{⊥∘⍵⍣⎕⊢⍺}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///3/FR24TqR11LH3XMeNS79VHv4kd9Ux91LXrUu6v2/38DPUMFRwU9AwMjBQMwPLRez8CUy8gUAA "APL (Dyalog Unicode) – Try It Online")
This takes `x` as the left argument, the coefficients of the function as the right argument, and `n` from STDIN.
Looking back at this after many a long time, I realised I could simplify the calculation by using base conversion `⊥`.
---
# APL (Dyalog), 5 bytes
If we can take the function as a Dyalog APL function, then this can be 5 bytes.
```
⎕⍣⎕⊢⎕
```
Takes `x`, `n` and then the function as input from STDIN.
[Answer]
# [R](https://www.r-project.org/), ~~96~~ ~~58~~ ~~55~~ 52 bytes
```
f=function(n,p,x)`if`(n,f(n-1,p,x^(seq(p)-1)%*%p),x)
```
[Try it online!](https://tio.run/##LYpJCoBADATv/kNIS0YSxaNfEUEMeBnHFX8/RvBUTVXvOVtvV5zOZY0UOfGDcbHRp1EM@omBjnmjhKAoqzLBL9mo44mEhRXcojBSEd7nm9zW0ngITv3ZASy1Ir8 "R – Try It Online")
### Explanation:
`seq(p)` generates the list `1, 2, ..., length(p)` when `p` is a vector, so `seq(p)-1` is the exponents of the polynomial, hence `x^(seq(p)-1)` is equivalent to `x^0` (always equal to 1)`, x^1, x^2, ...` and computing a dot product `%*%` with `p` evaluates the polynomial at `x`.
Additionally, if `P` is taken as a function, then this would be **38 bytes:**
```
function(n,P,x)`if`(n,f(n-1,P,P(x)),x)
```
And we can of course always generate `P` by `P=function(a)function(x)sum(x^(seq(a)-1)*a)`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
⁴ḅ$¡
```
[Try it online!](https://tio.run/##y0rNyan8//9R45aHO1pVDi38//@/gZ7h/2gDPQMjHQMdXSBtCKVNY/8bGhgAAA "Jelly – Try It Online")
Full program that takes `x p n` as command line arguments
## How it works
```
⁴ḅ$¡ - Main link. Takes x and p on the left
  $  - Previous 2 links as a monad f(x):
⁴    -   Yield p
 ḅ   -   Convert p from base x
   ¡ - Apply f(x) to x n times
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~70~~ 69 bytes
```
f=lambda p,n,x:n and f(p,n-1,sum(c*x**i for i,c in enumerate(p)))or x
```
Takes `p` in ascending order, i.e. if `p` is `[0, 1, 2]` then the corresponding polynomial is `p(x) = 0 + 1*x + 2*x^2`. Simple recursion solution.
[Try it online!](https://tio.run/##ZU7dDoIgFL73Kc4lOGSAdtPWk7QuSKHY8uhIN3t6O/7Mys4Y43y/tK/u3mA@jv70sPW1stAKFMMRwWIFntGWafHsa1amQ5oG8E2EIEoICA772kXbOdZyzgkfxonFiVMC9DEBmjYG7JhnZ4Im9CIABeScJ8mmjhZvjmnDd5asEJAZmZNTrkbayArrJD@FxNJd7EKK2URBW0ampZ76Pz1SHebfLUcqQ0JD0Kz7l9FDfym1Uot0fAM "Python 3 – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 82 bytes
```
using System.Linq;f=(p,n,x)=>n<1?x:p.Select((c,i)=>c*Math.Pow(f(p,n-1,x),i)).Sum()
```
[Try it online!](https://tio.run/##TY9Na8MwDIbv/hU62sMxS7vT3HSMwk4rDHLYofTguWpnSOQ0dtaM0N@eOTSFoYPQq@fVhw2Z9S2OXXB0gvI3RKw1@1@pd0dnzcjUGBpjEczAbGVCADuwEE10Ft46squD774q3O2loyhvxZzW47HgjSTZi2JNq/ylf25UiRXayLmVLqn2YWvit/rwF36c0CxPcOoIVXY1F6Nm910/3h1gaxxxMTB2XwrNa3uCAggvu/0A2ZOEbKGWEh5VDlfN0k1AN2ShZxf0s6CWafzGU/AVqs/WRUw/43RIAuRkkxMqhGbXKcY/ "C# (.NET Core) – Try It Online")
Takes a list of coefficients in the opposite order from the test cases (increasing order?) so that their index in the array is equal to the power x should be raised to.
And the trivial version in 30 bytes:
```
f=(p,n,x)=>n<1?x:f(p,n-1,p(x))
```
[Try it online!](https://tio.run/##VY9Na8MwDIbv/hU62p1jmnSnuekohZ5WGOyws@e6rSGVs9hpPcJ@e2YvHXQI9IXeR5L2hXadGXtv8QhvXz6YsyT3lXix@CkJqrPxrdIG1EB0o7wHPRAfVLAatj3q5a/bu/6jMXwKK24x8P@t8VDTliOPrF7hsnyOT4dcFyVvaWRslOQPenF2DztlkbKBkHs63FjQrrsj1EAzjM5FOdupcBKv7kojrxh7oEUlFrOYk0cmSboGcJJUkkwQiLeGWKTVG4feNUa8dzaY9Lih6bo0wLOM51GWON/Zxh8 "C# (.NET Core) – Try It Online")
Takes a delegate and applies it recursively n times.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
ii:"ZQ6Mw]&
```
[Try it online!](https://tio.run/##y00syfn/PzPTSikq0My3PFbt/38jPWMuY65oAz1DHV0gW0fXJBYA "MATL – Try It Online")
Slightly less interesting than my Octave answer, although I think there's some clever juggling of inputs to make sure `n=0` works as expected.
[Answer]
## Julia 0.6.0 (78 bytes)
`using Polynomials;g(a,n,x)=(p=Poly(a);(n>0&&(return g(a,n-1,p(x)))||return x))`
Explainations: 
The package [Polynomials](https://github.com/JuliaMath/Polynomials.jl) is pretty self explanatory: it creates polynomials. After that it's a pretty basic recursion. 
In order to have a polynomial: -4.0 - 2.3\*x + 0.1\*x^2 the input `a` must be like `a = [-4, -2.3, 0.1]` 
[Answer]
# Axiom, 91 bytes
```
f(n,g,x)==(for i in 1..n repeat(v:=1;r:=0;for j in 1..#g repeat(r:=r+v*g.j;v:=v*x);x:=r);x)
```
indented
```
fn(n,g,x)==
     for i in 1..n repeat
          v:=1; r:=0
          for j in 1..#g repeat(r:=r+v*g.j;v:=v*x)
          x:=r
     x
```
the input for polynomy g it is one list of numbers in the reverse of the example of exercise.
for example
```
[1,2,3,4,5]  
```
it would represent the polinomy
```
1+2*x+3*x^2+4*x^3+5*x^4
```
test:
```
(3) -> f(0,[0,0,1],3)
   (3)  3
                                                    Type: PositiveInteger
(4) -> f(1,[0,0,1],3)
   (4)  9
                                                    Type: PositiveInteger
(5) -> f(0,[-4,-2.30,0.1],2.3)
   (5)  2.3
                                                              Type: Float
(6) -> f(1,[-4,-2.30,0.1],2.3)
   (6)  - 8.7610000000 000000001
                                                              Type: Float
(7) -> f(2,[-4,-2.30,0.1],2.3)
   (7)  23.8258121
                                                              Type: Float
(8) -> f(9,[-4,-2.30,0.1],2.3)
   (8)  211.3326335688 2052491
                                                              Type: Float
(9) -> f(9,[-4,-2.30,0.1,0,0,0,0,1],2.3)
   (9)  0.4224800431 1790652974 E 14531759
                                                              Type: Float
                                   Time: 0.03 (EV) + 0.12 (OT) = 0.15 sec
(10) -> f(2,[-4,-2.30,0.1,0,0,0,0,1],2.3)
   (10)  44199336 8495528344.36
                                                              Type: Float
```
[Answer]
# [Röda](https://github.com/fergusq/roda), 41 bytes
```
f p,n,x{([0]*n)|x=_+p()|reduce _*x+_;[x]}
```
[Try it online!](https://tio.run/##K8pPSfz/P02hQCdPp6JaI9ogVitPs6bCNl67QEOzpig1pTQ5VSFeq0I73jq6Irb2f25iZp5CNRdnGlCpnqGOrpGesY6uSayOgrmOApCtyVX7HwA "Röda – Try It Online")
A trivial version:
```
f F,n{([_]..[0]*n)|reduce F(_)+_}
```
[Try it online!](https://tio.run/##FcpBCoAgFAXAdZ7iLbUiwkN4CSmRUmrRLyxBMM9uNOsJ52pr9VA9Za7NNAx6nFoSb3BrXBwUN6IzpfpICxIygntiIKRZorDD7oTMmiveG5cCLzz/Zw8pWKkf "Röda – Try It Online")
It takes the the value for `x` from the stream.
[Answer]
# C++14, 71 bytes
As generic unnamed lambda, returning via the `x` Parameter:
```
[](auto C,int n,auto&x){for(auto t=x;t=0,n--;x=t)for(auto a:C)t=a+x*t;}
```
Ungolfed and testcase:
```
#include<iostream>
#include<vector>
using namespace std;
auto f=
[](auto C,int n,auto&x){
 for(
  auto t=x; //init temporary to same type as x
  t=0, n--; //=0 at loop start, also check n
  x=t       //apply the result
  )
  for(auto a:C)
   t=a+x*t; //Horner-Scheme
}
;
int main() {
 vector<double> C = {0.1,-2.3,-4};//{1,0,0};
 for (int i = 0; i < 10; ++i) {
  double x=2.3;
  f(C, i, x);
  cout << i << ": " << x << endl;
 }
}
```
[Answer]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 19 bytes
```
[:|:=:*c^2+:*c+:}?c
```
Takes inputs as 
* Number of iterations
* starting value of x
* Then the 3 parts of the polynomial
Sample output:
```
Command line: 8 2.3 0.1 -2.3 -4
 59.30772
```
[Answer]
## Clojure, 66 bytes
```
#(nth(iterate(fn[v](apply +(map *(iterate(partial * v)1)%3)))%2)%)
```
Full example:
```
(def f #(nth(iterate(fn[v](apply +(map *(iterate(partial * v)1)%3)))%2)%))
(f 10 2.3 [-4 -2.3 0.1])
; 3976.0831439050253
```
Composing a function is 26 bytes:
```
#(apply comp(repeat % %2))
(def f #(apply comp(repeat % %2)))
((f 10 #(apply + (map * [-4 -2.3 0.1] (iterate (partial * %) 1)))) 2.3)
; 3976.0831439050253
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 18 bytes
Pretty straightforward, does what the challenge says on the tin.
```
o r_VË*ZpVÊ-EÉÃx}W
o                  // Take `n` and turn it into a range [0,n).
  r_            }W // Reduce over the range with initial value of `x`.
    VË             // On each iteration, map over `p`, yielding the item
      *Z           // times the current reduced value
        pVÊ-EÉ     // to the correct power,
              Ãx   // returning the sum of the results.
```
Takes inputs in order `n`, `p`, `x`.
[Try it online!](https://tio.run/##y0osKPn/P1@hKD7scLdWVEHY4S5d18Odh5srasP//zfSUYg20DPU0TXSM9bRNYnVUQAyAA "Japt – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 39 bytes
```
p!x=(iterate(\y->foldl1((+).(y*))p)x!!)
```
[Try it online!](https://tio.run/##LcUxDoMwDADAt0TqYBcSOZUY6UdohwgCRDXUggzweQwDt9wY1l9kVhWz1ZByXEKO8Nntu/9zxx6gQAf7E1FwMwZ1CmmuZUlzfkBDjl4llfba31dfQ86jJ9Kj7TkMq9pW5AQ "Haskell – Try It Online")
`(!)` takes as input a polynomial `p`, represented as a list of coefficients, a real number `x` and an integer `n`, and returns \$p^n(x)\$.
[Answer]
# [Factor](https://factorcode.org/) + `math.polynomials`, 35 bytes
```
[ [ [ polyval ] keep ] times drop ]
```
[Try it online!](https://tio.run/##fU@7DsIwDNz7FfcDrfpggg9ALCyICTFExYWoaRISg1Sqfntx2KksnR9nW3edatmF5Xw6HPdb9BQsGQyKHz8ovDOjdYNWJuJOloIy@qNYOxsR6fki21KED8Q8@qAtY5dNGTChLhrBfIM8VWVRYUaJ@S9XrXD12l16Oi8XpEhy38rgKk7IS2I9iL5bcNLITqdD5Ebmoti7SGLSI7Jq@2L5Ag "Factor – Try It Online")
Takes a value, a list of coefficients (high powers on the right), and the number of times to iterate, in that order. `polyval` is a builtin word that evaluates a polynomial given a value and a list of coefficients.
]