[Question]
  [
For those who didn't know, **[Sigma](https://en.wikipedia.org/wiki/Sigma)** is a Greek letter which is heavily used in mathematics as the summation sign. Given a string representing an expression depending on \$k\$ that we will denote \$E(k)\$, compute the sum of the results for \$E(k)\$, for each \$k\in\{1,2,3,4,5\}\$. Concisely, you should find \$S\$ such that:
$$S=\sum^5\_{k=1}E(k)$$
An example of an expression: \$E(k)=\frac k 2 + k^2\$
---
### Specs
* You are guaranteed:
	+ that the expression is valid, so it contains no errors, and that it's dependent of the syntax chosen (e.g: if you only support `2*k`, there will be no `2k`)
	+ to only have defined values amongst your results, so no values like `1/0`, `inf` or `nan` will appear
* You can assume that the expression above is fitting the limits of the programming language of your choice, so it won't result in overflows or any other limit-related errors
* Any other non-whitespace ASCII Character instead of `k` can be chosen
* Your program **must** support the following operations:
	+ addition (`+`, `plus()`,`add()`,`sum()`)
	+ subtraction (`-`, `minus()`, `subtract()`)
	+ exponentiation (`**`,`^`,`pow()` or others, should be specified), with support to negative bases and exponents
	+ square root in the form of `sqrt(k)`, `k^0.5`, `k**0.5`, or however else you wish
	+ multiplication and division
* The submission can either be a full program or a function, while mentioning its usage
* Any trailing / leading whitespace is allowed when outputting
* Minimum precision: 2 decimal places
### Test Cases (with `k`)
```
+---------------+--------------+   
|  Input = E(k) |    Output    |
|---------------+--------------|
|2*k            | 30           |
|---------------+--------------|
|sqrt(k)        | 8.38         | (* with minimum decimal precision)
|---------------+--------------|
|k+k/2+k**2     | 77.5         |
|---------------+--------------|
|k**2           | 55           |
+---------------+--------------+
```
The score will be the number of bytes (of the source + compiler flags). The lowest scoring valid submission wins, while taking note that [these loopholes](//codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are strictly forbidden. **[Here](https://tio.run/nexus/python3#S7ON@Z@TmJuUkqjgalVcmqsRnVqWmKNRXFKk4aqpV5RakJOYnKqhnq2uAxLK1NTUVEjLL1LIVMjMUyhKzEtP1TDUMdOM1fxfUJSZV6KRBlSqpWWkrqnJhRDQBgoZ6JmiCuoaoivSN9LG1KulZYwqoG8MVGmCMPI/AA)** is a Python pseudo-code, to make things clearer.
  
[Answer]
## Mathematica, ~~17~~ ~~14~~ 13 bytes
*Thanks to Ian Miller for saving 3 bytes.*
*Thanks to LegionMammal978 for saving 1 byte.*
```
#~NSum~{k,5}&
```
The input should be an actual expression containing `k`, e.g.:
```
#~NSum~{k,5}&[Sqrt[k]^3+4]
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~40~~ 37 bytes
3 bytes thanks to Arnauld.
Eval scope tricks \o/
```
f=lambda s,k=5:k and eval(s)+f(s,k-1)
```
[Try it online!](https://tio.run/nexus/python3#@59mm5OYm5SSqFCsk21rapWtkJiXopBalpijUaypnaYBFNU11PxfUJSZV6KRpqFkpJWtpKnJBedna2kZ6JmiCmln6xtpAyWM0FWCBP4DAA "Python 3 – TIO Nexus")
Uses `k**0.5` instead of `sqrt(k)`.
[Answer]
## JavaScript (ES7), ~~31~~ 30 bytes
Uses `k**0.5` for `sqrt(k)`.
```
f=(e,k=6)=>--k&&f(e,k)+eval(e)
console.log(f("2*k"))
console.log(f("k**0.5"))
console.log(f("k+k/2+k**2"))
console.log(f("k**2"))
```
[Try it online!](https://tio.run/nexus/javascript-node#@59mq5Gqk21rpmlrp6ubraaWBuJqaqeWJeZopGpycSXn5xXn56Tq5eSna6RpKBlpZStpaqKLZmtpGeiZYpPQztY30gZKG2HXBRL@/x8A)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
vÐ€5S
```
[Try it online!](https://tio.run/nexus/jelly#@192eMKjpjWmwf8PtwPp/4b/o7k4lR7uWKKkA6QP7QVT2h7ahzZBBDYpccUCAA "Jelly – TIO Nexus")
Input a valid Jelly monadic chain (I golfed them down in my link).
## How it works
```
vÐ€5S
 Ð€     for each of ...
   5        5 (implicitly converted to [1,2,3,4,5]), ...
v           evaluate the input with the above as argument
    S   and find the sum
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~8~~ ~~7~~ 6 bytes
```
6G¹.VO
```
[Try it online!](https://tio.run/nexus/05ab1e#@2/mfminXpj///9@Cn5G@tp@RrnaAA)
Input is in postfix notation, and **uses the variable N**. 05AB1E is a stack-based language, so only postfix notation works. 
Format of `E(N)`: write the number(s) you want to do the operation with, and then write the sign of the operation. For example, `3+4` would be `3 4+`, `3*4+2*3` would be `3 4* 2 3* +`. Also note that this uses `t` instead of `sqrt`, and `m` instead of `**`, so `sqrt(N)` would be `Nt`.
**Explanation:**
```
6G¹.VO
6G     For N in range(1,6). This includes [1,2,3,4,5].
  ¹.V  Read and eval input.
     O Sum results.
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~50~~ ~~46~~ ~~31~~ 29 bytes
```
@(d)eval(["k=1:5;sum(" d 41])
```
[Try it online!](https://tio.run/nexus/octave#S7ON@e@gkaKZWpaYoxGtlG1raGVqXVyaq6GkkKJgYhir@T9NQ8lITytbSZMLyCouLCrRyNaEcLK1s/WNtLP14oygfDDrPwA "Octave – TIO Nexus")
Exponentiation is denoted with the caret `.^` and multiplication is denoted with `.*`.
This declares an anonymous function that takes in argument `d`. It sets `k` to be equal to the range `1:5` and sums the evaluated `d` and returns it.
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), 10 bytes
```
6ÆK=XOxUÃx
```
Input string should have variable as an uppercase `K`. `sqrt(K)` should be inputted as `K**0.5`.
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=NsZLPVhPeFXDeA==&input=IksrSy8yK0sqKjIi)
## Explanation
`eval` scope didn't work in my favor; had to redefine the counting variable `X` as a global `K`.
```
6ÆK=XOxUÃx      // implicit: U = input string
6oXYZ{K=XOxU} x // expanded
6oXYZ{      }   // create array [0, 6) and map to function:
      K=X       //   redefine the array value to global K
         OxU    //   eval the input string
              x // sum the resulting array
```
[Answer]
# Octave, ~~25~~ 23 bytes
```
@(f)sum(inline(f)(1:5))
```
[Try it online!](https://tio.run/nexus/octave#@@@gkaZZXJqrkZmXk5mXCuRoGFqZamr@LyjKzCtJ01BSzYzJU9JRSMwr1lA30spW19S05sImV1xYVKKRrYlTPls7W99IO1svzgi3EqjkfwA)
Exponentiation is denoted as `.^`
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 9 bytes
```
+/⍎⎕⊣k←⍳5
```
[Try it online!](https://tio.run/nexus/apl-dyalog#e9TRnvZfW/9Rb9@jvqmPuhZnP2qb8Kh3s@n/Rx3t/9O41I0OT89W5wIysrX0TCEMbY3sw9uNNLWztYygMkbqAA "APL (Dyalog Unicode) – TIO Nexus")
Addition is `+`, subtraction is `-`, multiplication is `×`, division is `÷` exponentiation is `*` and execution is right to left, so use `()` to group expressions.
Input is in terms of `k`.
### Explanation
```
k←⍳5                    Set k to be equal to the vector 1 2 3 4 5
⊣                       The left argument:
+/                      Sum of
⍎⎕                      The evaluated input (the eval returns an array because k is an array)
```
---
And here's a solution that takes trains as input (like the Jelly answer): [`+/(⍎⎕)¨⍳5`](https://tio.run/nexus/apl-dyalog#e9TRnvZfW1/jUW/fo76pmodWPOrdbPr/UUf7/zQudaPD0x91LVLnAjL1TLUe9a6A8YC0tobR4e0QIU1tI2RJOAcA "APL (Dyalog Unicode) – TIO Nexus").
[Answer]
# Common Lisp, 55 bytes
```
(defun f(x)#.(read))(print(+(f 1)(f 2)(f 3)(f 4)(f 5)))
```
[Try it online](https://tio.run/nexus/clisp#@6@RkppWmqeQplGhqaynUZSamKKpqVFQlJlXoqGtkaZgqAkkjECEMYgwARGmmpqa//9raClUAGUA)
```
Example input - output: 
(* x 2) - 30 
(sqrt x) - 8.382333 
(+ (/ x 2) x (expt x 2)) - 155/2 
(expt x 2) - 55
```
different, longer (58 bytes) version - starts getting shorter if you do sumation from 1 to 7.
```
(print #.`(+,@(mapcar #'(lambda(x)#.(read))'(1 2 3 4 5))))
```
yet another and longer method (~~65~~ 64 bytes) - doesn't define function - just inserts your expression into a loop. Should get shorter for bigger sums.
```
(setf a(read)b 0)(loop as x from 1 to 5 do(incf b #.a))(print b)
```
[Answer]
# Swift, ~~202~~ 184 bytes
```
import Foundation;func s(i:String){print([1,2,3,4,5].map{NSExpression(format:i.replacingOccurrences(of:"k",with:"\($0).0")).expressionValue(with:nil,context:nil)as!Float}.reduce(0,+))}
```
For some reason this will only run locally :(.
Here is an explanation of what I am doing:
```
import Foundation // Import the Foundation module
func s(i:String){ // Create a function that takes in a String and returns a Float
    print( // Print the result of the follow algorithm to strdout
        [1,2,3,4,5].map{ //Conduct the follow code on numbers 1 - 5
            NSExpression(format: // Create an expression with the following String and return it 
            i.replacingOccurrences(of:"k",with:"\($0).0")) // Create a string replacing all ocurrances of 'k' in `i` with the current Float from the map
           .expressionValue(with:nil,context:nil)as!Float // Get the resulting value of the expression
       }.reduce(0,+) // Add the result of all the expressions together
    )
}
```
Thanks to @Mr. Xcoder for saving 15 bytes!
[Answer]
# TI-Basic, 12 bytes
```
Σ(expr(Ans),K,1,5
```
Call with `"string":prgmNAME`, where `string` is any valid TI-Basic expression of `K`.
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 16 bytes
```
5~>[@k#~]2/"!sum
```
[Try it online!](https://tio.run/nexus/stacked#q1bM@29aZxftkK1cF2ukr6RYXJr7P08hRkFHQaUotaBIITexQEFdwdYOSGTlZ@Yp5JeWKNRycWlwKahnKxgpaKmDGcWFRSUQFkhQH0zGKWgraKtD1cWpc2kCTQWa9h8A "Stacked – TIO Nexus")
`5~>` is a range from 1 to 5 incluive. `2/` makes a func dyadic, `"` is pair-wise, and `!` is execute. This thus maps the range `[1, 5]` with the input, which is then evaluated after defining the range member to be `k`. Then, the results are summed.
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~31~~ 24 bytes
```
?sa1k[lax+Kd1+k5>p]dspxp
```
The input must be given in reverse-Polish notation (also known as postfix notation) and enclosed in square brackets (`[]`) with: 
* `K` replacing `k` as the parameter;
* `+` representing addition;
* `-` representing subtraction and `_` followed by any number representing a negative number;
* `*` representing multiplication;
* `/` representing division;
* `^` representing exponentiation;
* `v` representing the square-root.
For example, `-2*k+k+3*k**2+k**0.5-k/2` would be input as `[_2K*K+K2^3*+Kv+K2/-]`. This takes due advantage of the fact that `K` is a `dc` command which returns the current precision (initially set to `1`). Therefore, by the end, this returns the output with a precision of `6`.
[Try it online!](https://tio.run/nexus/dc#@29fnGiYHZ2TWKHtnWKonW1qVxCbUlxQUfD/f7S3kVbs17x83eTE5IxUAA "dc – TIO Nexus")
[Answer]
# [R](https://www.r-project.org/), 35 bytes
```
k=1:5;sum(eval(parse(t=scan(,""))))
```
[Try it online!](https://tio.run/##K/qvnFaal1ySmZ@nUaGTbWtoZapZXJqrkVqWmKNRkFhUnKpRYluhqanJpZymoWSkla0EYRUXFpVoZGtCedna2fpG2tlaWkYwAQjzP9hAawwDi5MT8zR0lJSA5mr@B6nl@g8A "R – Try It Online")
TIO link includes a function solution as well (38 bytes)
[Answer]
# [Tcl](http://tcl.tk/), 58 bytes
```
proc S {f s\ 0} {time {incr k
set s [expr $s+$f]} 5
set s}
```
[Try it online!](https://tio.run/##JczBCsIwEIThe55iDnvQFLQEfJIe1YOEBMq2GrNbEEKePQ31Mj/M4VO/tJbyx2NCiZAHxoqi8xpQ5rfPYCNBIbiHX8ogGSg@K27/t7ZlfSVEFGeJId@sJ@IziAfiq7uMPdY6HNtdkzbt1ISOmNp2 "Tcl – Try It Online")
If it only worked with integers, I could golf it more!
]