[Question]
  [
# Round away from zero
Inspired by [Round towards zero](https://codegolf.stackexchange.com/q/190670/52194).
Given a number input via any reasonable method, round the number "away from zero" - positive numbers round up, and negative numbers round down.
If you intend to take the input as a string (via STDIN, for example), you should be able to handle numbers with or without the decimal point. If you take it as a number, it should at least be able to handle floating-point precision (double precision not required) or rational numbers.
You can output a floating-point number with the decimal point (e.g. 42.0) if desired. (Or even have some test cases output floating-point and some output integer, if it makes your answer shorter.)
Standard loopholes are not allowed, etc etc.
## Test cases
```
-99.9 => -100
-33.5 => -34
-7    => -7
-1.1  => -2
0     => 0
2.3   => 3
8     => 8
99.9  => 100
42.0  => 42
-39.0 => -39
```
[Sandbox Link](https://codegolf.meta.stackexchange.com/a/18016/52194)
  
[Answer]
# Excel, 13 bytes
```
=ROUNDUP(A1,)
```
### Alternative
```
=EVEN(A1*2)/2
```
[Answer]
# R, 32 bytes
```
x=scan()
sign(x)*ceiling(abs(x))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ĊṠ¡Ḟ
```
A monadic Link accepting a number which yields an integer.
**[Try it online!](https://tio.run/##y0rNyan8//9I18OdCw4tfLhj3v///3WNjfVMAQ "Jelly – Try It Online")** Or see a [test-suite](https://tio.run/##y0rNyan8//9I18OdCw4tfLhj3v/D7Y@a1vz/H61raalnqaOga2ysZwqkzIHYUM9QR8FAR8FIz1hHwUJHAaQiFgA "Jelly – Try It Online").
### How?
```
ĊṠ¡Ḟ - Link: number, N
  ¡  - repeat...
 Ṡ   - ...number of times: sign of N (repeating -1 is the same as 0 times)
Ċ    - ...action: ceiling
   Ḟ - floor (that)
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 18 bytes
```
d->d.setScale(0,0)
```
[Try it online!](https://tio.run/##VZBBT4QwEIXv/IoJCUlroIFFo@y6ezDGmyeOxkMXChZLIXTAbAy/HYHdAB6avq8zffPagnfcK9LvQZZ11SAUI7OS4xe7O1jbsxalYlmrE5SVnoqJ4sbAO5cafi2Auj0rmYBBjuPWVTKFcqyRGBup849P4E1u6NwK8HbzeX6R@atIZMmVu8oTZHAcUu@UMiMwTrgSxHd9Ohzmy4sjCoMGjjdPANuLIhbZ7oJhyB42@LjRAQtW8le5Y@EKT6v873y/Y/52TjTiTP01YlY1pOPNnHB/zUmXmPHFoChZ1SKrx5dgRmwn8M0eHONo253bXcgYr2t1IVr8wPo1ZCpSSq9jemta/fAH "Java (JDK) – Try It Online")
## Explanations
Uses a `BigDecimal` as input and output. `BigDecimal` has a method [`setScale`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/math/BigDecimal.html#setScale(int,int)) that sets the scale of the number. The first parameter is the number of digits after the dot separator, the second is the rounding mode. `ROUND_UP` is the "away-from-zero" rounding and has a value of `0` so I hardcode that value.
[Answer]
# Vim, 36 bytes/keystrokes
```
:s/-/-<Space>
:g/\..*[1-9]/norm <C-v><C-a>lD
:s/<Space><cr>
```
[Try it online!](https://tio.run/##K/v/36pYX1dfV4HLKl0/Rk9PK9pQ1zJWPy@/KFdBjDHHhQsorcD1/7@uoYGBniUA) or [Verify all Test Cases!](https://tio.run/##K/v/30q1WF9XX1eByypdP0ZPTyvaUNcyVj8vvyhXQYwxx4ULJK/w/7@upaWeJZeusbGeKZeuOZeuoZ4hlwGXkZ4xlwUXSAoA)
Explanation:
```
:s/             " Replace...
   -            "   A dash
    /-<Space>   "   With a dash and a space
:g/                             " On Every line matching this regex...
   \.                           "   A dot
     .*                         "   Followed By anything
       [1-9]                    "   Followed by a digit other than 0
            /norm               " Run the following keystrokes...
                  <C-v><C-a>    "   Increment the number by 1
                                "   This also conveniently places our cursor just before the dot
                            l   "   Move one character right
                             D  "   Delete everything after the cursor
:s/             " Replace...
   <Space>      "   A space
                "   (With nothing)
```
[Answer]
# [Python 3](https://docs.python.org/3/), 23 bytes
```
lambda i:i-i%(1|-(i>0))
```
[Try it online!](https://tio.run/##FcpBCoMwEEbhfU/xb4oJTIJpEJugnqQbSwkO6CjipqhnT@3i8W3e8t2GWXxO7SuP/fT@9ODIhu/KHUZxV2qd07xCwAITgg0E472tLuorZx2hJDysJzwJ/yPesKwsm0rFLrGpTrQd9qREn4XOPw "Python 3 – Try It Online")
*-1 byte thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor)*
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 4 bytes
```
AĊ×Ṡ
```
[Try it online!](https://tio.run/##y0rNyan8/9/xSNfh6Q93Lvh/dM/h9kdNa9z//9e1tNSz1FHQNTbWMwVS5kBsqGeoo2Cgo2CkZ6yjYKGjAFIBAA "Jelly – Try It Online")
This ports [recursive](https://codegolf.stackexchange.com/a/191248/66833)'s Stax answer into Jelly, so check that answer out for an explanation.
-1 byte thanks to [Nick Kennedy](https://codegolf.stackexchange.com/users/42248/nick-kennedy)
# [Jelly](https://github.com/DennisMitchell/jelly), ~~6~~ 5 bytes
```
ĊḞ>?0
```
[Try it online!](https://tio.run/##y0rNyan8//9I18Md8@zsDf4f3XO4/VHTGvf//3UtLfUsdRR0jY31TIGUORAb6hnqKBjoKBjpGesoWOgogFQAAA "Jelly – Try It Online")
-1 byte thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)
## How this one works
```
ĊḞ>?0 - Monadic link. Takes a float, x, as argument
   ?  - If:
  > 0 -   x > 0
      - Then:
Ċ     -   ceil(x)
      - Else:
 Ḟ    -   floor(x)
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 6 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
å├╪∙Bß
```
[Run and debug it](https://staxlang.xyz/#p=86c3d8f942e1&i=-99.9%0A-33.5%0A-7.0%0A-1.1%0A0.0%0A2.3%0A8.0%0A99.9%0A&a=1&m=2)
### Procedure:
1. Absolute value
2. Ceiling
3. Multiply by original sign
[Answer]
# [J](http://jsoftware.com/), 6 bytes
```
**>.@|
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/tbTs9Bxq/mtypSZn5CvEGxoYKNgqpCnEW1rqWULEjMAChnqGCgoKUFUQoXiwGETI1MAQLGZqYKBnAlNlYQJRZ2RhrGcKVwhVhzANxAarMzX4DwA "J – Try It Online")
Just a 1 character change from [my answer on the cousin question](https://codegolf.stackexchange.com/a/190684/15469).
[Answer]
# JavaScript (ES6), 20 bytes
```
n=>n%1?n<0?~-n:-~n:n
```
[Try it online!](https://tio.run/##Xc/BCoJAEMbxe08xl0APM@46ha5oPouYRiGzkuHRV98K1oI5//jz8T26tVv6531@ofjrEMYmSHORo22lNu2GUuEmlYTey@KngSZ/S8YEnSOXppBlgNaYg1JmOkflk8YCACIW2izZ3XJlBn6d3suJd2JF5b8qFX0vRPpcCG8 "JavaScript (Node.js) – Try It Online")
### Commented
```
n =>        // n = input
  n % 1 ?   // if n is not an integer:
    n < 0 ? //   if n is negative:
      ~-n   //     return -(floor(-n) + 1) = -floor(-n) - 1
    :       //   else:
      -~n   //     return -(-(floor(n) + 1)) = floor(n) + 1
  :         // else:
    n       //   return n unchanged
```
[Answer]
# [C# (Visual C# Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~41 bytes~~~~27 bytes~~24 bytes
```
s=>(int)s+Math.Sign(s%1)
```
[Try it online!](https://tio.run/##TU@xasMwEJ19X3FLQaKyiOOW1rjOUujUQCFDh5BBqJIjcGWqu6SU4G93VZOh0713vPfunqXSkp1PFGKPux9i99nCf6ZfQ/xqwQ6GCN/gAgWx4WDxPIYP3JoQURCnbNgf0KSeJBRZVFzdL6don/wwGlYYIm/QYzdTtxGZSLrdGj7qXeijoJtKzi3A2SRkR4wdRveNi3V/uJRNoxuvsKxrfe9V@ZBhpau8WSlc6zqDR4VX0d1arxZtk@eUQ/2YnLFHsYTnP5YL8q/M8xhpHJx@T4FdruqEFyxlCxNAMcE0/wI "C# (Visual C# Compiler) – Try It Online")
First post here, had fun with it, hope u like it.
Kinda felt C# place is empty here
-14 tnx to @expired data  
-3 tnx to @night2
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), ~~18~~ 16 bytes
```
1µ-i:'-A{*+'.A@
```
[Try it online!](https://tio.run/##KyrNy0z@/9/w0FbdTCt1XcdqLW11PUeH//91jYwt9QwB "Runic Enchantments – Try It Online")
"Adds" (away from zero) 0.999999 and floors the result. `µ` is the closest thing to an infinitesimal in language's operators. With a properly functioning `Trunc(x)` command, answer now supports `0` as input.
[Answer]
## C, ~~94~~ ~~43~~ 39 bytes
thanks to ceilingcat for 39 bytes 
```
#define f(n)(int)(n>0?ceil(n):floor(n))
```
[TIO](https://tio.run/##PY3NCsIwEIRfpVSEBEzIn7RR0BfxUtKkBNKtVG/iqxtjknqZ@XZnhzVkMibG3WidB9s4BBh5eGIEF3Y11oe0OLmwLGsCHFPUzIMHhF/3NQ0OtfuxIZyxG/xAquJdMZGtZDJrn3W7V6LWdHtIv4nWVONMUtJjoY6yApzyDKwuBJXZ@zr/y0psFakT4fM7fowLw/SIJMxf)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
*±¹⌈a
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8b/WoY2Hdj7q6Uj8//9/tK6lpZ6ljq6xsZ6pjq65jq6hnqGOgY6RnrGOhQ5YysRIzwAob6lnEAsA "Husk – Try It Online") Just takes the sign of the input times the ceiling of its absolute value.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 38 bytes
```
\.0+
.
\b9+\..
0$&
T`9d`d`.9*\..
\..*
```
[Try it online!](https://tio.run/##FYoxCoAwEAT7fYdYJNxyMYjePyxTRImFjYX4/zMWw8Awz/le9@5eqBFEOSwWEjqM2Kq12iot/KUT4C5mNEjOnCELVSGJmqBUTMxYu//lAw "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
\.0+
.
```
Delete zeroes after the decimal point, to ensure that the number is not an integer; the next two matches fail if there are no digits after the decimal point.
```
\b9+\..
0$&
```
If the integer part is all `9`s, prefix a `0` to allow the increment to overflow.
```
T`9d`d`.9*\..
```
Increment the integer part of the number.
```
\..*
```
Delete the fractional part of the number.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÄîI.±*
```
A 5-byter should definitely be possible..
[Try it online](https://tio.run/##yy9OTMpM/f//cMvhdZ56hzZq/f@va2mpZwQA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/wy2H11XqHdqo9V/nf7SupaWepY6usbGeqY6uuY6uoZ6hjoGOkZ6xjoUOWMrESM8AKG@pZxALAA).
**Explanation:**
```
Ä       # The absolute value of the (implicit) input,
 î      # ceiled
     *  # And then multiplied by
   .±   # the signum
  I     # of the input
        # (after which the result is output implicitly)
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 18 bytes
```
Sign@#⌈Abs@#⌉&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7PzgzPc9B@VFPh2NSMYjuVPsfUJSZVxKtrGuX5qAcq6bvUM2la2mpZ6nDpWtsrGcKpMyB2FDPUIfLQIfLSM9Yh8tChwuiwsRIzwCkzlLPgKv2PwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 18 bytes
```
{$_-.abs%-1*.sign}
```
[Try it online!](https://tio.run/##NYxJDoJAEEX3dYpaqDhQlR5U6AVchBCDkTYkCKZ7YYjx7C2D/tX7b/GetWvP4THgxmIW3qsLcXX1a5J79s29@wRfDWi3By5EuYsxwihGLlSJtnfYNl3t85xfvbv5QMawwSxHkkIAac2n@ekjUILjppMASZYLKxD48wIU6wU1pH@bwpyccEx@AQ "Perl 6 – Try It Online")
### Explanation
```
{                }  # Anonymous block
    .abs  # Absolute value
        %-1  # Modulo -1
           *.sign  # Multiply by sign
 $_-  # Subtract from original
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 5 bytes
```
‼σ±ü*
```
[Try it online!](https://tio.run/##y00syUjPz0n7//9Rw57zzYc2Ht6j9f@/rqWlniWXrrGxnimXrjmXrqGeIZcBl5GeMZcFF1jKxEjPAChvqWcAAA "MathGolf – Try It Online")
## Explanation
It's nice to find usage for the `‼` operator. 
```
‼       apply next two operators to (implicit) input
 σ      sign (-1, 0, or 1)
  ±     absolute value
   ü    ceiling of that absolute value
    *   multiply the rounded absolute value with the sign
```
[Answer]
# [PHP](https://php.net/), 30 bytes
```
<?=0^$argn-=0<=>fmod($argn,1);
```
[Try it online!](https://tio.run/##K8go@P/fxt7WIE4lsSg9T9fWwMbWLi03P0UDzNcx1LT@n5qcka@gFJOnZP1f19JSz5JL19hYz5RL15xL11DPkMuAy0jPmMuCCyxlYqRnAJS31DP4l19QkpmfV/xf1w0A "PHP – Try It Online")
If number is not integer, based on the sign -1 (for negative decimals) or 1 (for positive decimals) is added to it and then integer part of the new number is printed.
---
# [PHP](https://php.net/), 32 bytes
```
<?=[ceil,floor][$argn<0]($argn);
```
[Try it online!](https://tio.run/##K8go@P/fxt42Ojk1M0cnLSc/vyg2WiWxKD3PxiBWA8zQtP6fmpyRr6AUk6dk/V/X0lLPkkvX2FjPlEvXnEvXUM@Qy4DLSM@Yy4ILLGVipGcAlLfUM/iXX1CSmZ9X/F/XDQA "PHP – Try It Online")
Basically outputs `floor` of input if it is less than 0, else `ceil` of it.
---
# [PHP](https://php.net/), 34 bytes
```
<?=($argn>0?:-1)*ceil(abs($argn));
```
[Try it online!](https://tio.run/##K8go@P/fxt5WQyWxKD3PzsDeStdQUys5NTNHIzGpGCKqqWn9PzU5I19BKSZPyfq/rqWlniWXrrGxnimXrjmXrqGeIZcBl5GeMZcFF1jKxEjPAChvqWfwL7@gJDM/r/i/rhsA "PHP – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
⌋₁ℤ₁|⌉₁
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3w/1FP96OmxkctS4BkzaOeTiD1/390vKWlnqVOvLGxnqlOvLlOvKGeoY6BjpGesY6FDljKACgQDyRiAQ "Brachylog – Try It Online")
or `⌉₁ℕ₁|⌋₁`.
```
⌋₁         The input rounded down
  ℤ₁       is an integer less than -1
    |      and the output, or, the input
     ⌉₁    rounded up is the output.
```
[Answer]
# [Factor](https://factorcode.org/), 57 bytes
```
: f ( x -- x ) [ signum ] [ abs ceiling ] bi * >integer ;
```
[Try it online!](https://tio.run/##PYw9D4IwFEV3fsUd1aQNHxotJK6GhcU4GQeopTZCIaUk@utrU4jLeee@5N625nYw7nYtq0uOtzBadOhr@wqg7ay5VYOeMBph7Xc0SlsUUVnl4MNTEDl0rcvRYoMPCPHY4o5JST33eHitmwlcqE5p6XOjsMPZbwgpDApHGKPMt2lEsowesOhxvQlNgsSBKc2W/ynw39ynNF4n2GLuBw "Factor – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 15 bytes
```
{⍎'⌈⌊'[0>⍵],⍕⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/6sf9fapP@rpeNTTpR5tYPeod2uszqPeqUC69n8aUAVQGqK4q/nQeuNHbROBvOAgZyAZ4uEZ/P9R76pqdc@8gtISKwV1oMatOuoK/qUlUH4ayJhDKw6tt7TUs1QA6jfWMwVS5kBsqGeoYKBgpGesYKEAljUx0jMAKbHUMwAA "APL (Dyalog Unicode) – Try It Online")
Simple Dfn. Uses `⎕IO←0`.
### How:
```
{⍎'⌈⌊'[0>⍵],⍕⍵} ⍝ Main function, argument ⍵.
            ⍕⍵  ⍝ Stringified argument
           ,    ⍝ Appended to
      [0>⍵]     ⍝ This item... (0 if ⍵ is positive or 0, else 1)
  '⌈⌊'          ⍝ of this string (which are the functions Ceiling and Floor, respectively)
 ⍎              ⍝ Executed as APL code.
```
[Answer]
# sed, 131 bytes + 2 bytes for `-r` flag
```
/^-?[^.]*(\.0*)?$/bQ
s/^(-?)9/\109/
s/([0-8]9*)\..*$/_\1/
h
s/.*_//
y/0123456789/1234567890/
G
s/(.*)\n(.*)_(.*)/\2\1/
:Q
s/\..*$//
```
## Ungolfed
```
#!/bin/sed -rf
# identify integers
/^-?[^.]*(\.0*)?$/ b isInt
# add a leading 0 if we'll need it later
s/^(-?)9/\109/
# convert to format: -?[0-9]_[0-8]9*
s/([0-8]9*)\..*$/_\1/
# move the part that will remain constant into the hold buffer
h
s/.*_//
# [0-8]9* can be incremented via character substitution
y/0123456789/1234567890/
# reassemble parts
G
s/(.*)\n(.*)_(.*)/\2\1/
:isInt
# Get rid of anything after the decimal point
s/\..*$//
```
[Answer]
# [Perl 5](https://www.perl.org/) `-pF/\./`, 35 bytes
```
$_&&=$F[0]+($_!=int&&$_*(@F-1)/abs)
```
[Try it online!](https://tio.run/##K0gtyjH9/18lXk3NVsUt2iBWW0MlXtE2M69ETU0lXkvDwU3XUFM/MalY8/9/Yz0DLl0TPVMuAyDD4l9@QUlmfl7xf92cAjf9GD19AA "Perl 5 – Try It Online")
[Answer]
## JavaScript (node.js), ~~30~~ ~~23~~ 21 bytes
```
s=>~~s+Math.sign(s%1)
```
Inspired by the C# answer.
Thanks to @Value Ink and @Gust van de Wal for -7 bytes!
Thanks again, @Gust van de Wal for another -2 bytes!
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~45~~ ~~38~~ 37 bytes
```
[int]("$args"-replace'\.0*[^0]','.9')
```
[Try it online!](https://tio.run/##RY1dT4MwFIav6a84aaqAKU2hmI2LJST@AI3zjqFh9cyPsIEUosnkt2PHR7zq@6Tv@5y6@sbGvGNZBrpqcGCHzXnIPk5t7lFWNG@GBg3WZaHR3Ql5kz3L3OWuSFx/6AlJPcJTL0gSkXAIQin9kZUSt5ZVPOHK5tUUQxFaiEaQHKZ@JBQHNcY1h/UYJuVipHEkJOUQT0saqGRk@/rEh1@4gjNx2Kk77rHhwPCnRt3iK2yAvdiPBk1Xtpau2QHmGnGyh@1dZ9rqeL//tPUcUitxtp3WaMxlOs8C/PpX2gZ9QtOCLgzSS2vROY/LlXlInJ70ZPgD "PowerShell Core – Try It Online")
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~54~~ 48 bytes
```
$a,$u=$args-split'\.'
(1,-1)[2*!+$u+($a-lt0)]+$a
```
[Try it online!](https://tio.run/##XY5dT4MwFIav119xJNWBtA1QzEYMCYnx2sV5NxfD8MyPMEFaosnkt2NHWWbsTd@nPe/T1tUXNuoVy5IXVYM93ab7nuaMtinNmxfFVV2@6emjmBI3ZDz0VtHlmU9b36U5L3XgrX2a9x0hmUtY5vIkEQkDHgaBN7CU4sqwjC3OTJ7ZGIrQQDRAwMDOR0IykEOcM5gPwSqPRieOROAwiG3T4TIZ2Owe8eAHzmFPJvSj3W2wYUDxu8ZC4zOkQJ@uzU2Dqi21wQu6hXHOnK8Wy5tW6Wp3t3k3hTVkRjNZtkWBSh3KY4/j50lqJpwHVBqKXKFzmLI@Av/W/fHRUWOKt38@dvJ1pCP9Lw "PowerShell Core – Try It Online")
Thanks [@mazzy](https://codegolf.stackexchange.com/users/80745/mazzy) for the improved golfing !
## Original implementation
```
$a,$u="$args"|% s*t '.'
(((1,-1)[$a-lt0]+$a),$a)[!+$u]
```
[Try it online!](https://tio.run/##TY3RSsMwFIavm6c4hsy1LgltU9mKFAritYN5N4p09UyRzs4mQWHrs9esnbqLkP87Od@fffOFrX7DuhZV02LPttmhZyVnNqOsbF81PU5A3xiYyinxfT/iIgrWrBS1CYsZKwPuzvpqxmzRd4TkPuG5L9JUphxEFIbBwErJW8cqGXHu8nyMkYwcxAOEHMb9WCoOaogLDoshjJW/jTSJZUg5JKNJhUoHdndAAjjCBA7EYx92t8GWA8PvPVYGXyAD9nznXlrUtjYOr9kWzntuvl6u7q02ze5x8@6EAnJX461sVaHWJ/nsCfz8L3WeR59QG6hKjfS09lfoPVz8fCF0pCP9Dw "PowerShell Core – Try It Online")
## Explanations
```
$a,$u="$args"|% s*t '.'        # splits the input as a string using '.'
                        [!+$u] # if there are no decimals
(                   ,$a)       # return the int part as is
 ((1,-1)[$a-lt0]+$a)           # return the int part + or - one depending of the sign of the input
```
[Answer]
# [Julia 1.0](http://julialang.org/), 17 bytes
Save 6 bytes thanks to the awesome comments of [MarcMush](https://codegolf.stackexchange.com/users/20260/xnor)!
```
x->x+sign(x%=1)-x
```
[Try it online!](https://tio.run/##FYrLCsIwEEV/5VIqzOAkNAbRLNIvcSP0wYiMpSrk72NcXM7hcB/fp95DqUuuxY3l@NbVqBxyYNfia4dCDeRS8kngYvTnhktb8EEwCE4@Cq6C/4Ox7Wof6npSRh7R09KMb9YxZpvqDw "Julia 1.0 – Try It Online")
An alternative with 22 bytes
```
x->sign(x)ceil(abs(x))
```
[Try it online!](https://tio.run/##FYrBCsIwEAV/5VF62IVNMAbRHNov8VK1kZWyllYhfx/jYZg5zOu76BRKzUMtbtz1aVT4PutC021vyTW/NyjUQC4lnwQuRn9qOjeCD4KD4Oij4CL4H4x1U/tQ15MyhhE95VZ8tY4x26P@AA "Julia 1.0 – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `r`, ~~5~~ 4 bytes
*Built-ins I previously didn't know existed FTW!*
```
ȧ⌈∆±
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=r&code=%C8%A7%E2%8C%88%E2%88%86%C2%B1&inputs=-33.5&header=&footer=)
Explanation:
```
      # Implicit input
ȧ     # Absolute value
 ⌈    # Ceiling
  ∆±  # Change to the sign of input
      # Implicit output
```
]