[Question]
  [
Given a real number, convert it to a list of lists, with the negative sign (if any) becoming an empty list, the integer part becoming a list of digits, and the fractional part (if any) becoming a list of digits. The digits must be actual numbers, not strings.
### Examples
`0` ‚Üí `[[0]]`
`123` ‚Üí `[[1,2,3]]`
`-123` ‚Üí `[[],[1,2,3]]`
`123.45` ‚Üí `[[1,2,3],[4,5]]`
`0.45` ‚Üí `[[0],[4,5]]`
`-0.45` ‚Üí `[[],[0],[4,5]]`
`-123.45` ‚Üí `[[],[1,2,3],[4,5]]`
  
[Answer]
# C#, ~~60~~ 66 bytes
```
using System.Linq;s=>s.Split('-','.').Select(p=>p.Select(c=>c-48))
```
[Try it online!](https://tio.run/##jVBNSwMxEL3nVwy5bEKzoWoFod1cioqiIPTQQ@khplMNbJO6kxWk9Lev6ad68/Lmg3mPec9RuYohdi358AaTL0q4GrLfk37y4WPImKstEbywDaNkk3fwGf0Cnq0PQublXRvciFKTiepIHMe6Rpd8DKTvMWDjnX64De0KG/ta4@ifZz4kYwwsoYKOKkN6sq59EkVZqEIXUk9wRxfryqxPvauMKwc3Unb58UVss8xsDgkpjS0hZaUN9BVcXF4pKPeYQQ@uFfT3WB7LYQvbIVvGBq17B3FQO2uBDz@6ko2ziVijnjY@YQ4OBZ9x6MEhmGw1OJvEUpzpPeD8bMFCZeAP4THmeLniCqzc3c65PNXsbMu23Tc "C# (Mono) ‚Äì Try It Online")
[Answer]
# JavaScript (ES6), ~~33~~ ~~44~~ ~~43~~ 41 bytes
Takes input as a string. Sacrificed ~~11~~ 10 bytes converting the elements in the output to numbers after the challenge spec was updated.
```
s=>s.split(/\D/).map(a=>[...a].map(eval))
```
* Saved a byte thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)'s suggestion of using `eval`.
---
## Test it
```
console.log((
s=>s.split(/\D/).map(a=>[...a].map(eval))
)("-123.45"))
```
---
## Explanation
```
s=>
```
Anonymous function taking the string as an argument via parameter `s`.  
`"-123.45"`
```
s.split(/\D/)
```
Use RegEx to split the string to an array on all non-digit characters - i.e., `-` and `.`  
`["","123","45"]`
```
.map(a=>)
```
Map over the array, passing each string to a function via parameter `a`.
```
[...a]
```
Split to an array of individual character strings.  
`[[],["1","2","3"],["4","5"]]`
```
.map(eval)
```
Map over the subarray and `eval` each string, which converts it to an integer.  
`[[],[1,2,3],[4,5]]`
[Answer]
# [Python 2](https://docs.python.org/2/), 58 bytes
```
lambda x:[map(int,i)for i in`x`.replace(*'-.').split('.')]
```
[Try it online!](https://tio.run/##DctBCoAgEEDRq7hzJkooaBN0kgqyUhpQG8ygTm/u/uJ9/tJ5hS7bcc5O@@3Q4h0mrxkopJrQXlGQoLC@q4qGnd4NVLJREtXNjhLIkkvmWDjYMvGTABFz06r@Bw "Python 2 ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~13~~ 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
≈í·πò¬µ<‚Äù/≈ìpV‚Ç¨
```
A monadic link taking a number and returning the resulting list of lists of numbers.
**[Try it online!](https://tio.run/##y0rNyan8///opIc7ZxzaavOoYa7@0ckFYY@a1vw/3A4W/f9fV8/EFAA "Jelly ‚Äì Try It Online")** (the footer just prints the python representation to show all the actual lists)  
...or see the [test suite](https://tio.run/##y0rNyan8///opIc7ZxzaavOoYa7@0ckFYY@a1vw/uudwO1hcBcjLAuJHDXMUdO0UgGoi//@PNtBRMDQy1lHQBZNAQs/EVEcBTOhCSIhYLAA "Jelly ‚Äì Try It Online").
### How?
```
≈í·πò¬µ<‚Äù/≈ìpV‚Ç¨ - Link: number
≈í·πò         - Python representation (yields a string representation of the number)
  ¬µ        - monadic chain separation (call that s)
    ‚Äù/     - literal '/' character
   <       - less than? (vectorises) ('.' and '-' are, digit characters are not)
      ≈ìp   - partition s at truthy indexes of the resulting list discarding the borders
        V‚Ç¨ - evaluate ‚Ç¨ach (list of characters) as Jelly code (vectorises)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~12~~ 11 bytes
Thanks to *Riley* for saving a byte. Code:
```
'-'.:'.¬°ŒµS√Ø
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f9fXVddz0pd79DCc1uDD6///1/X0MhYz8QUAA "05AB1E ‚Äì Try It Online")
Explanation:
```
'-'.:            # Replace "-" by "."
     '.¬°         # Split on "."
        Œµ        # Apply to each element..
         S       #   Split into a list of characters
          √Ø      #   Convert back to int
```
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
```
lambda a:[[]]*(a<0)+[map(int,n)for n in`abs(a)`.split('.')]
```
[Try it online!](https://tio.run/##JYzBDoIwEETvfsXe2FVsFOVC9EtKE5ZoYxNYGroXv74UvbzM5E0mfvWzSJP9s88Tz@OLgTtrnTsiPy50sjNHDKK1kF9WEAgy8JiQaTApTkGxMhW5vEt9Jy0e8Nrcajj/WGDu7b@VQN0BIK7lED3ue6K8AQ "Python 2 ‚Äì Try It Online")
-5 bytes from Felipe Nardi Batista
[Answer]
# [Actually](https://github.com/Mego/Seriously), 23 bytes
```
'.@;)A$s‚å†‚ôÇ‚âà‚å°M[[]]+@s~@t
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/19dz8Fa01Gl@FHPgkczmx51djzqWegbHR0bq@1QXOdQ8v@/rqGRsZ6JqRkA "Actually ‚Äì Try It Online")
Explanation:
```
'.@;)A$s‚å†‚ôÇ‚âà‚å°M[[]]+@s~@t
'.                       push "."
  @;)                    make a copy of the input and move it to the bottom of the stack
     A$s                 absolute value of input, stringify, split on periods
        ‚å†‚ôÇ‚âà‚å°M            convert integer and fractional parts to lists of digits
             [[]]+       prepend an empty list
                  @s~    bitwise negation of sign of input (1 -> -2, 0 -> -1, -1 -> 0)
                     @t  elements in the list starting at that 0-based index (drops the leading empty list if the input was positive)
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 11 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
Œñ-.≈ó .Œò‚å°ƒç¬πr
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMzk2LS4ldTAxNTclMjAuJXUwMzk4JXUyMzIxJXUwMTBEJUI5cg__,inputs=LTEyMy40NTY_)
Outputs to the top of the stack (because SOGL converts it to a multiline string because it is made for ascii-art). To view the result, look in the console after  ``r`@10:` (the outer brackets are the stack arrays) or just append `Œø√∏‚àë` after the code
```
Œñ-.≈ó         replace "-" with "."
     .Œò      split on "."s
       ‚å°     for each
        ƒç      chop into characters (casts to strings :/)
         ¬π   wrap in array (this + for each is like map())
          r  reverse types, vectorizing
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt/) (v2.0a0), ~~12~~ ~~10~~ 8 bytes
Takes input as a string.
```
q\D ¬Æ¬¨¬Æn
```
[Test it](http://ethproductions.github.io/japt/?v=2.0a0&code=cVxEIK6srm4=&input=Ii0xMjMuNDUiCi1R) (`-Q` flag for visualisation purposes only.)
* 2 bytes saved thanks to [Justin](https://codegolf.stackexchange.com/users/69583/justin-mariner).
* 2 bytes saved thanks to ETH.
---
## Explanation
Implicit input of string `U`.
```
q\D
```
Use RegEx to split (`q`) to an array on all non-digit characters.
```
¬Æ
```
Map over the array.
```
¬¨
```
Split each string to an array of individual characters.
```
¬Æ
```
Map over the array.
```
n
```
Convert to integer.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 54 bytes
```
@(x)cellfun(@(c){c-48},strsplit(num2str(x),{'-' '.'}))
```
Anonymous function that takes a number as input and produces a cell array of numeric vectors.
[Try it online!](https://tio.run/##y08uSSxL/Z@mYKugp6f330GjQjM5NScnrTRPw0EjWbM6WdfEolanuKSouCAns0QjrzTXCMgBqtKpVtdVV1DXU6/V1PyfpqFraGSsZ2Kq@R8A "Octave ‚Äì Try It Online")
### Explanation
```
@(x)cellfun(@(c){c-48},strsplit(num2str(x),{'-' '.'}))
@(x)                                                    % Function with input x
                                num2str(x)              % Convert x to string
                       strsplit(          ,{'-' '.'})   % Split at '-' or '.'. Gives a
                                                        % cell array of substrings
    cellfun(          ,                               ) % To each substring apply
                                                        % the following function
            @(c){c-48}                                  % Subtract 48 from each char
                                                        % and pack into a cell
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~170~~ ~~164~~ ~~152~~ ~~146~~ 144 bytes
Should be able to golf this down a bit...
```
#define P printf
#define V *v[1]
main(c,v)char**v;{for(V^45?P("[[%c",V++):P("[[],[%c",V++,V++);V;V^46?P(",%c",V++):P("],[%c",V++,V++));P("]]");}
```
[Try it online!](https://tio.run/##S9ZNT07@/185JTUtMy9VIUChoCgzrySNCyYQpqBVFm0Yy5WbmJmnkaxTppmckVikpVVmXZ2WX6QRFmdiah@goRQdrZqspBOmra1pBebF6sAEwILWYdZAlWYglTrICtGUaVqDxGKVNK1r////r2toZKxnYgoA "C (gcc) ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
≈í·πò‚Åæ-.y·π£‚Äù.V‚Ç¨‚Ç¨
```
[Try it online!](https://tio.run/##y0rNyan8///opIc7Zzxq3KerV/lw5@JHDXP1wh41rQGi/4fbwXL//@sa6pkCAA "Jelly ‚Äì Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 16 bytes
```
$'.'-(√Ü'.@s‚å†‚ôÇ‚âà‚å°M
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/19FXU9dV@Nwm7qeQ/GjngWPZjY96ux41LPQ9/9/XQM9E1MA "Actually ‚Äì Try It Online")
Explanation:
```
$'.'-(√Ü'.@s‚å†‚ôÇ‚âà‚å°M Implicit eval'd input
$                Convert to str
 '.              Push '.'
   '-            Push '-'
     (           Rotate stack left
      √Ü          Pop a, b, c; push c.replace(b, a)
       '.        Push '.'
         @       Pop a, b; push b, a (swap)
          ‚å†‚ôÇ‚âà‚å°   Push function ‚ôÇ‚âà
           ‚ôÇ       Map
            ‚âà        Convert to int
              M  Map
```
[Answer]
## R, ~~51~~ ~~47~~ 72 bytes
```
x=RG::s(strtoi(s(gsub('-','.',scan()),on='\\.')))
x[is.na(x)]=list(NULL)
```
I'm loving the `RG` library.
Had to add 26 bytes to make sure the empty list was actually empty.
```
               gsub('-','.',scan())             # replace - with . in input; also converts to string
             s(                    ,on='\\.')   # split string on '.'
      strtoi(                                )  # convert to numeric
RG::s(                                        ) # convert to lists of digits
    x[is.na(x)]=list(NULL)                      # converts list of `NA` to empty list
```
Example output:
```
> x=RG::s(strtoi(s(gsub('-','.',-123.45),on='\\.')))
> x[is.na(x)]=list(NULL)
> x
[[1]]
NULL
[[2]]
[1] 1 2 3
[[3]]
[1] 4 5
```
[Answer]
# [Perl 5](https://www.perl.org/), 56 54 + 1 (-p) = 55 bytes
```
$_="[[$_]]";s/\D\K\./0./;s/\d(?=\d)/$&,/g;s/-|\./],[/g
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lYpOlolPjZWybpYP8YlxjtGT99ATx/ESdGwt41J0dRXUdPRTwcK6NYA5WJ1ovXT///XNTQy1jMx/ZdfUJKZn1f8X7cAAA "Perl 5 ‚Äì Try It Online")
*Saved two bytes due to Dom reminding me about $&* 
**Explanation:**
```
$_="[[$_]]";        # Add opening and closing to ends of strings
s/\D\K\./0./;       # handle the case of .45 or -.45 by inserting 0 before
                    # the decimal.  Otherwise, .45 & 45 would be ambiguous.
s/\d(?=\d)/$&,/g;   # Put a comma between numbers.
s/-|\./],[/g        # Turn - and . into separators between lists
```
[Answer]
# [Perl¬†6](https://perl6.org), 23 bytes
```
+¬´*.split(/\D/)¬ª.comb
```
[Test it](https://tio.run/##VZFNbsIwEIX3PsUItcUGx4R/CSuoiy677C5kkSaDFOEQizioUdUT9QjdcbHU@SHAbvy9p2e/scaTWlVFjnBeiUiStISXKIsRvGp8@R2JXKvE0MnubcIufyLK0s@qMb0azA14QAmAC94WfN8NeMDtcTqbt2DKZ3zeQaenAe@Eq1kslg9@f8GXrej2knuPnRu3@FG6z@tv6g1Mkrrqh327JFqFRxg3RSTZZ6euk7MFCpsDlvQpOerCMA6bc6gKpI3OgMG3vcnuYIdfGiODsd1Do4k01HQk3hM7JgZT1ozSupPciRG1KqFe7i35msBhANBSsU8NHT6v8yGra7TB2n4TZQPyU/0D "Perl 6 ‚Äì Try It Online")
## Expanded
```
+¬´\            # numify each of the following (possibly in parallel)
*\             # WhateverCode lambda (this is the input)
.split(/\D/)\  # split on non-digits ( . and - )
¬ª.comb         # split each of those into individual characters
```
Note that `‚Ä¶¬ª.comb` is a higher precedence than `+¬´‚Ä¶`
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
```
lambda x:(x<0)*[[]]+[map(int,i)for i in`abs(x)`.split('.')]
```
[Try it online!](https://tio.run/##LY3BDoMgEAXv@xV7E1ok1NaLqV9CScQ0pJsoEuVAvx7R9jKTvMO88I2fxTfZ9a882Xl8W0wdS0/FL1obc9WzDYx8FMTdsiIh@cGOG0t8kFuYKLJKVtxk6rUScGvuAuqTBfLRClAn679@q4GjlUoLqQMMazlAV5qIeQc "Python 2 ‚Äì Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 13 bytes
```
r'-'.er'./::~
```
[Try it online!](https://tio.run/##S85KzP3/v0hdV10vtUhdT9/Kqu5/wn9dAz0TUwA "CJam ‚Äì Try It Online")
[Answer]
# Pyth, 12 bytes
```
sMMcXz\-\.\.
```
[Try it here.](http://pyth.herokuapp.com/?code=sMMcXz%5C-%5C.%5C.&input=-0.45&debug=0)
[Answer]
# [Perl 6](http://perl6.org/), 22 bytes
```
{m:g/^\d*|\d+/¬ª.comb}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/OtcqXT8uJkWrJiZFW//Qbr3k/Nyk2v/WCsWJlQpKKvEKtnYK1WkaKvGaeumZxSW1Sgpp@UUKNgYKhkbGCrogAoj1TEwVDECELoSECNlZ/wcA "Perl 6 ‚Äì Try It Online")
The elements in the returned list are strings, but as is normal for Perl, they can be used as numbers and will be converted implicitly; they are "actual numbers" for all practical purposes. To force them to be numbers in their most immediate representation, one need only prefix the contents of the code block with "+¬´" for three more bytes.
[Answer]
# RUBY, 75 bytes
```
->(x){(x<0?[[]]:[])+x.abs.to_s.split('.').map{|y|y.chars.map{|z|z.to_i}}}
```
[Try it online!](https://tio.run/##vYzLCgIhGIX3PkW7UWJ@7LaJLg8iEo5MJVjJ6IDO6LNb5itEi/PBuXCGsQs562N7wp7M2B/omTHO94yTpQfRWXCviwVrtHK4gYbAQ5g5hhhA3sVgq53iVHYqpZTN6OxCgxRa41vvvgeKgHpa00uHfl9f/1NnilbrDWoLPoLtDtGCtrJGbw "Ruby ‚Äì Try It Online")
]