[Question]
  [
Disclaimer: This challenge is inspired by a coding error I once made.
---
Okay, time for a maths lesson. A normal mean average looks like this:
```
Work out the sum of all numbers in a list
then divide by the size of the list.
```
But what if we don't know all the numbers at the time we're working out the average? We need a way to work out the average which can be added to over time. For this reason, I present the algorithm for a Progressive Mean™
```
The running total is the first number in the list
For each of the remaining numbers
  Add the number to the running total
  Divide the running total by two
```
So in effect we're averaging each number with the current average. (We could add to this later and get the same result)
**BUT**
This doesn't give the same result at all. It gives an average, but it differs from the standard methodology for finding the mean. Now the order of the list of numbers is significant.
Of course, being a curious type, I want to work out if the Progressive Mean™ tells us anything about the order of our list of numbers. So for this reason I want to compare Mean with Progressive Mean™ by means of a simple subtraction:
```
trend = Progressive Mean™ - Standard Mean
```
---
# The Challenge
* Write a piece of code which accepts a list of numbers (in any format) which then calculates three pieces of information about it:
	+ Standard Mean
	+ Progressive Mean™
	+ Trend (Progressive - standard)
* Work in any language you like.
* It's golf, attempt to do the challenge in as few bytes as you can.
* Avoid Standard Loopholes
* I want the output to be human-readable numbers.
* Please include a link to an online interpreter such as tio.run
---
Test Cases:
```
[1,2,3]
Normal Mean:        2.0
Progressive Mean:   2.25
Trend:              0.25
```
```
[3, 2, 1]
Normal Mean:        2.0
Progressive Mean:   1.75
Trend:              -0.25
```
```
[10, 20, 30]
Normal Mean:        20.0
Progressive Mean:   22.5
Trend:              2.5
```
```
[300, 200, 100]
Normal Mean:        200.0
Progressive Mean:   175.0
Trend:              -25.0
```
```
[10, 100, 10]
Normal Mean:        40.0
Progressive Mean:   32.5
Trend:              -7.5
```
```
[4, 4, 9, 8, 1, 8, 6, 9, 1, 1]
Normal Mean:        5.1
Progressive Mean:   2.62890625
Trend:              -2.4710937499999996
```
```
[1, 1, 1, 4, 4, 6, 8, 8, 9, 9]
Normal Mean:        5.1
Progressive Mean:   8.5390625
Trend:              3.4390625000000004
```
```
[9, 9, 8, 8, 6, 4, 4, 1, 1, 1]
Normal Mean:        5.1
Progressive Mean:   1.47265625
Trend:              -3.6273437499999996
```
  
[Answer]
# [R](https://www.r-project.org/), 57 bytes
```
function(v,`!`=sum,N=!1^v)c(A<-!v/N,P<-!v/2^c(N:1,N),P-A)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jTCdBMcG2uDRXx89W0TCuTDNZw9FGV7FM308nAEwbxSVr@FkZ6vhp6gToOmr@T9MwtDLW5ErTSNYw0VEAIksdBQsdBUMwaQbmAtmGmiAlhpr/AQ "R – Try It Online")
A clever collaboration with digEmAll and RobinRyder; uses the observation by [Grimmy](https://codegolf.stackexchange.com/a/198894/67312) and Kevin's explanation from the comments, which I replicate below:
> 
> For anyone else wondering why the example `[a,b,c,d] -> [a,b,c,c,d,d,d,d]` doesn't match the explanation of the code, it actually transforms `[a,b,c,d]` to `[a,b,b,c,c,c,c,d,d,d,d,d,d,d,d,a]` (so two of each value in comparison to the example). The example confused me for a moment. But nice answer, +1 from me! I also like that it has all these different types of the letter 'A' in the code: `āÅÅAÂÆª`. xD
> 
> 
> 
This uses R's recycling rules to use two copies of `l[1]/2^N` in the sumby just sticking an extra `N` at the end of the decay rate.
# [R](https://www.r-project.org/), 62 bytes
```
function(l)c(p<-Reduce(function(x,y)(x+y)/2,l),a<-mean(l),p-a)
```
[Try it online!](https://tio.run/##K/qfpmCjq/A/rTQvuSQzP08jRzNZo8BGNyg1pTQ5VQMuXKFTqalRoV2pqW@kk6Opk2ijm5uaCFKtU6CbqPk/TcPQyliT6z8A "R – Try It Online")
Straightforward implementation.
[Answer]
# [J](http://jsoftware.com/), 17 bytes
Translation of [this](https://codegolf.stackexchange.com/a/198889/43319).
```
-:@+/@|.(,,-)+/%#
```
Anonymous tacit prefix function. Returns list of Progressive Mean™, Standard Mean, Trend.
[Try it online!](https://tio.run/##JYtRCoAwDEP/PUVABMWp7SZjE4SdZh@ewbtrupGPpC/p8331vrBdZT3Ku8/Obct6TCMxFB5hqAh0pavAC4IYEstCJL3QdjCfVEbic0Jk0v7aZF0kT@SZNLel7axpmx8 "J – Try It Online")
This consists of three parts: `(2÷⍨+)⌿∘⌽` `(,,-)` `+⌿÷≢`
`+/ % #` is the sum divided by the number of elements
…`⌿@|.` reverses the list and then reduces from right to left using the function:  
 `-:@+` add next value to previous value and halve that
`(,,-)` is the concatenation of the PM and the SM, concatenated to their difference
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 70 69 bytes
-1 byte thanks to [Kyle Gullion](https://codegolf.stackexchange.com/users/32604/kyle-gullion)
returns `(mean, p_mean, trend)`
```
lambda x:(m:=sum(x)/len(x),[p:=x[0],*[p:=(p+n)/2for n in x]][-1],p-m)
```
[Try it online!](https://tio.run/##VcrBCsMgDAbg@54ix7hZqvUyBJ/EeejYZIWaBteBe3pnexj0kPzh@8Pf9bWQuXKuERzc6jym@2OEYjFZ9/4kLKKfn9RCeraueBXkebuQLyT6IS4ZCCaCEoLvdJDcJVE5T7RiRK8lDBJMEOL0N7ObPphWDdsYdXxVu7el1dbUHw "Python 3.8 (pre-release) – Try It Online")
Alternate version with more of a reducer implementation (89 bytes):
```
lambda x:(m:=sum(x)/(l:=len(x)),[x:=[sum(x[0:2])/2]+x[2:]for n in range(l-1)][-1],x[0]-m)
```
Although this is longer, I suspect this reducer implementation may be useful for future python 3.8 code golfing.
[Try it online!](https://tio.run/##VcpNCsMgEAXgfU8xS4ca4s@mCJ7EziKlsQ2oEZuCPb21WRSyeMPjm5c/23NN@pJL82Dh2sIUb/cJqmHR2Nc7soojC8aGOfWK3FVj3e5OGEU4KjpXpwz5tUCCJUGZ0mNmYZBIbpDE@5CGiC2XJW3MMyc5KA6aEE9/07vJg0nRsUeL41Ts3o8Uv0/7Ag "Python 3.8 (pre-release) – Try It Online")
I know there has to be some more clever tricks to golf this further...
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÅAIÅ»+;}θ‚ÂÆª
```
Outputs as a triplet `[mean, progressive-mean, trend]`.
[Try it online](https://tio.run/##yy9OTMpM/f//cKuj5@HWQ7u1rWvP7XjUMOtw0@G2Q6v@/4820VEAIksdBQsdBUMwaQbmAtmGsQA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/w62OlYdbD@3Wtq49t@NRw6zDTYfbDq36r/M/OtpQx0jHOFYn2hhIGwJpQwMdIwMdYwOQkAGIbaBjaGAAkTAEc4BsEx0THUsdCx1DIDYDsgwhWkG0DkjODChuARS3BIpaglWC1IFkwGpiYwE).
**Explanation:**
```
ÅA     # Calculate the arithmetic mean of the (implicit) input-list
I      # Push the input-list again
 Å»    # Left-reduce it by:
   +   #  Add the two values together
    ;  #  And halve it
 }θ    # After the reduction, leave only the last value
‚      # Pair it with the earlier calculated arithmetic mean
 Â     # Bifurcate this pair; short for Duplicate & Reverse copy
  Æ    # Reduce it by subtraction
   ª   # And append this trend to the pair
       # (after which the result is output implicitly)
```
[Answer]
# Scratch 2.0/3.0, 35 blocks/263 bytes
[![Blocks](https://i.stack.imgur.com/xBbNb.png)](https://i.stack.imgur.com/xBbNb.png)
SB Syntax:
```
when gf clicked
set[i v]to(2
set[L v]to(length of[I v
set[T v]to(item(1)of[I v
set[P v]to(T
repeat((L)-(1
change[T v]by(item(i)of[I v
change[P v]by(item(i)of[I v
set[P v]to((P)/(2
change[i v]by(1
end
set[T v]to((T)/(L
say(join(join(join(join(P)[,])(T))[,])((P)-(T
```
It's accidentally a polyglot. I accidentally forgot my password and email for my other scratch account so I had to make a new one so y'all can [Try it on Scratch!](https://scratch.mit.edu/projects/364915100/)
Y'all need to change the input list shown in the top left corner on the project for this to work properly.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~81~~ \$\cdots\$ ~~75~~ 71 bytes
Saved ~~1~~5 bytes thanks to [Reinstate Monica](https://codegolf.stackexchange.com/users/85755/reinstate-monica)!!! 
```
def f(l):
 m=sum(l)/len(l);p=l[0]
 for n in l:p=(p+n)/2
 return m,p,p-m
```
[Try it online!](https://tio.run/##ZY1BCsMgEEX3nmKWSi3RGEpMyUlCdo00oEZssujp7aA0IIFx1DfPb/ju782rlF6LAUMtGwi48XM4PDZ28bg9w2gnMRMwWwQPqwc7hJGGm2dNSyAu@xE9OB54uLsU4up3augkObQc1MwYOZnKTFZMCoS4lKhVkTk2KcTlgSyDinccsDSHHke5P/JVXn4sLOtdtvpc6OpK1P@4klV0eSamHw "Python 3 – Try It Online")
[Answer]
# JavaScript (ES6), 55 bytes
Returns `[mean, p_mean, trend]`.
```
a=>a.map(v=>t=(s+=v,n++)?(t+v)/2:v,n=s=0)&&[s/=n,t,t-s]
```
[Try it online!](https://tio.run/##dY7RCoMgFIbv9xRehaKVVowanPYg0YW0GhvNYoqv70TZLobB8cDh@78fn9JKPb0fu8nVdpvdAk5CL4uX3LGF3gDWFCxTlJIrNtSSsrr4EzRwkmWDLkExw0yuRzdtSm/rXKzbHS94EAxVDNUjIac/UgciEkRwj/yreUrjgfolOD@QRcQJ2jDkp2Oo9YGwz@EUBz@JJEhNyLZhvNEl4t23OvZGSfza3Qc "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
```
āÍoîÅΓ‚ÅAÂÆª
```
[Try it online!](https://tio.run/##yy9OTMpM/f//SOPh3vzD6w63npv8qGHW4VbHw02H2w6t@v8/2kRHAYgsdRQsdBQMwaQZmAtkG8YCAA "05AB1E – Try It Online")
The progressive mean is equivalent to a weighted arithmetic mean, with exponentially increasing weights. For example, the progressive mean of a 4 element list `[a, b, c, d]` is the arithmetic mean of `[a, b, c, c, d, d, d, d]`.
```
ā              # range [1..length of input]
 Í             # subtract 2 from each
  o            # 2**each: [0.5, 1, 2, ...]
   î           # round up: [1, 1, 2, ...]
    ÅΓ         # run-length decode
      ‚        # pair with the input
       ÅA      # arithmetic mean of each list
         Â     # push a reversed copy
          Æ    # reduce by subtraction
           ª   # append
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~20~~ 18 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
-2 thanks to Bubbler.
Anonymous tacit prefix function. Returns list of Progressive Mean™, Standard Mean, Trend.
```
(2÷⍨+)⌿∘⌽(,,-)+⌿÷≢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X8Po8PZHvSu0NR/17H/UMeNRz14NHR1dTW0gFyjRueh/2qO2CY96@x71TfX0f9TVfGi98aO2iUBecJAzkAzx8Az@n6ZgqGCkYMyVpmAMpA2BtKGBgpGBgrEBSMgAxDYAChlAJAzBHCDbBAgtFSyAmi0UzIAsQ4hWMATJmQHFLYDilkBRS7BKkDqQDFgNAA "APL (Dyalog Unicode) – Try It Online")
This consists of three parts: `(2÷⍨+)⌿∘⌽` `(,,-)` `+⌿÷≢`
`+⌿ ÷ ≢` is the sum divided by the count
`(`…`)⌿∘⌽` reverses the list and then reduces from right to left using the function:  
 `2÷⍨+` add next value to previous value and divide that by two
`(,,-)` is the concatenation of the PM and the SM, concatenated to their difference
[Answer]
# [Factor](https://factorcode.org/), ~~80~~ 79 bytes
```
: f ( s -- s ) [ mean ] [ dup first [ + 2. / ] reduce ] bi 2dup swap - 3array ;
```
[Try it online!](https://tio.run/##TZBBS8NAEIXv/RXvqMjGTSIlSY8epAeLIJ5KD2s6aRfTNO5MlFL62@MkJVIGljfvezPLbuVKOYb@4325einwRaGhGgcn@4jFiWfxJYPpu6OmJB4JXAjuxGgDiZza4BvBYrZcFXh2ddnVTsjInsxbOO4CMfsfMq/kmr5AhTswjNHjHmsc1MVGxbZrUfnAovoBSYRHtQNtu5JUfHokQ4J/XQuDdLwfi/6MGYAzYiRIcbk2qTbx1MQWiUVq/6EdDKu@vYnEozMZT1o5Ml2SYa4qvlk31hCYK8wU5hPKx5lhYsDX4AUzpWt99UY/rkXU/wE "Factor – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 31 bytes
```
{a=Mean@#,b=+##/2&~Fold~#,b-a}&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zg@7860dY3NTHPQVknyVZbWVnfSK3OLT8npQ7I102sVfsfUJSZVxKdFl1tqKNgpKNgXBsba80FFzQGCxqiChoaAEWB2NgATbEBWAJIGBoYYGoxhMigSpjoKACRpY6CBVAOTJqBuYaYtkIEwepNwMoswAio2BJVpSXMQIhpEPWGCDP/AwA "Wolfram Language (Mathematica) – Try It Online") Pure function. Takes a list of numbers as input and returns a list of rational numbers as output. I'm pretty sure that improper fractions count as human-readable, but if they aren't, adding `N@` (+2 bytes) to the start causes the function to output approximate numbers.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Æm;+H¥/ṄI
```
A full program which accepts a list of decimals which prints:
```
[mean, progressive-mean]
trend
```
**[Try it online!](https://tio.run/##y0rNyan8//9wW661tsehpfoPd7Z4/v//P9pERwGILHUULHQUDMGkGZgLZBvGAgA "Jelly – Try It Online")**
### How?
```
Æm;+H¥/ṄI - Link: list of numbers, A
Æm        - arithmetic mean       sum(A)/length(A)            = mean
      /   - reduce (A) by:
     ¥    -   the dyad f(leftEntry, rightEntry):
   +      -     addition          leftEntry + rightEntry
    H     -     halve            (leftEntry + rightEntry) / 2 = progressiveMean
  ;       - concatenate           [mean, progressiveMean]
       Ṅ  - print this list and yield it
        I - deltas                [progressiveMean - mean]
          - implicit print (Jelly represents with a single item as the item)
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 54 bytes
```
$args|%{$y+=$_;$z=($_+$z)/(2-!$i++)}
($y/=$i)
$z
$z-$y
```
[Try it online!](https://tio.run/##TY/RCoIwGIXv9xQL/nJjv7iphCKD3kS6yDIkRS9CzWdfc7ZqHMbO2fcftq59XvrhdmkaA5WeDZz76/DazzAKDWUBk2ZQCph4xOJwB7UQfCEMxkhDzQlMViGMZiGEQEc1ZUxhjAlHQu1iiTXKGyUxlpjI76VcA4lKyj9EucQHKVKrHGmGVLn96Kw9/3o368jUAZmTxXLP5L5ka9jIzyDn6@PXT5fhva0fAQbFASp6KosgWMwb "PowerShell – Try It Online")
Takes input by splatting. The only neat trick is the `!$i++` bit which negates the first iteration where `$i` is 0 to 1, and all subsequent numbers to 0.
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg)(Perl 6), 41 40 bytes
```
{|($/=(.reduce((*+*)/2),.sum/$_)),$0-$1}
```
My original solution had `my \a=`and used `[-]|@a` at the end, but abusing `$/` is always fun, especially with also abusing assignments. Pretty straightforward calculation wise.
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1pF31ZDryg1pTQ5VUNDS1tLU99IU0evuDRXXyVe07pGRV9HxUBXxbD2vzVXcWKlQppGtLGOkY5hrOZ/AA "Raku – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 111 109 bytes
```
#define P printf("%f "
f(a,l,i)int*a;{float s=*a++,p=s;for(i=l-1;i--;p+=*a++,p/=2)s+=*a;P,s/=l);P,p);P,p-s);}
```
[Try it online!](https://tio.run/##TY7dCsIwDIXv@xRhIqxby5yIKKHv4L14UWYrhdqVdt449uyzqz8YDgnn5COk47eum@fVVWnjFJzAB@MGXRZrDQXRpWSWGZqiSuKobS8HiKKSdc28iKj7UBpheYuGc/T1Z9OILY2LwROLjbA0TZ8bjxSnmaR7cJfGlZSMBFItgQzhfAEBY8vgrV3WnsEh65g04Y@3yiU6mqfq058hUGj@3HlzoUgynD1b@G8S1PAIDjZIpvkF "C (gcc) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 27 bytes
```
≔∕ΣθＬθη≔§θ⁰ζＦθ≔⊘⁺ιζζＩ⟦ηζ⁻ζη
```
[Try it online!](https://tio.run/##LYzBCsIwEETvfsUeNxBBQUTpqehBQaHgseQQmtgEYkqTtEh/Pm5r4R2Gmcc0Roamky7nMkbberza0SqNr@GDPePw0L5NhiJlw4rNapXp7pX@Ys9hR8tEy7sLQB6sxk26USus3BDRzsaqVcH6hBcZE9aGKg5P68mZ5n/BWJFzXe85/DksHDmcFs6EEHk7uh8 "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔∕ΣθＬθη
```
Calculate the arithmetic mean.
```
≔§θ⁰ζ
```
Start with the first element. We therefore end up averaging this element with itself, but that doesn't affect the final result of course.
```
Ｆθ≔⊘⁺ιζζ
```
Loop over each element an average it with the progressive mean so far.
```
Ｉ⟦ηζ⁻ζη
```
Print the arithmetic and progressive means and their difference.
If we had only needed the result once then `ΣＥθ∕ιＸ²⁻Ｌθ∨κ¹` could have been used to calculate the progressive mean directly, saving 3 bytes over the naïve method.
[Answer]
# Haskell, 84 bytes
I thought Haskell could do decently here because this challenge works on lists and I tend to think Haskell and lists go well together... But I couldn't come up with anything very clever. Let's see if @xnor drops by and has anything nice :P
```
f(h:l)=g$foldl(\(p,s,w)n->((p+n)/2,s+n,w+1))(h,h,1)l
f[]=f[0]
g(p,s,l)=(s/l,p,p-s/l)
```
I am defining an anonymous function `\(p,s,w) n -> ((p+n)/2, s+n, w+1)` that receives a triplet and the next list element, and does three things: updates the progressive mean, sums the whole list and computes its length. In the end, function `g` does some last-minute calculations.
You can [try it online](https://tio.run/##fY5BDoIwEEX3nGIWLtowQgvEiAmewJ1LZGGipcZaGovh@DgpuizJdKbN/@9P9dU/78bMs2L6YHjTb9RgboZdmEOPE7fbI2MutTwv0KcWp1RyzjRqlNwkqu0a1You6YOdeOZzgw7dliafX9eHhQZuQwLgPuN5fJ8sbMDrYaKhoO1igsyyMiqWWKCMowKhoFOKeIAIHmpSiNUguZiingqBqkbYky30XXjSfeWHix7QKhD7UMTVUaj@r1l2LOgvqZu/ "TIO link with the test cases")
[Answer]
# [PHP](https://php.net/), ~~90~~ 88 bytes
```
function($i){for($j=$i[0];$x=$i[$c++|0];$s+=$x,$j+=$x,$j/=2);return[$s/=$c-1,$j,$j-$s];}
```
[Try it online!](https://tio.run/##VZDRaoMwFIavm6cIci4sptTUMto52RNs7GJ3VorYOC1bIokdha7P7o4ntWxwjP9//u8cQrqmG56eu6ZjDHrlescznrNZLgVfCZ4UAnVCWpKWMRr8kthHMXk8ZBzfAekb5NeCY20F32CLzgey8r7Ra8LWlG6okNkSsJ3G/azHblMFK1K8eZ0N9UlXfWt0CO38UhsbwjGDNo@LFM6jgCqKfkbnogzOAo633zJbzVOr@pPVObhlBtVCYhtrAa5Ir0PKcJsqq4aH/PZEpUPF5/zCZmDxwaAOqZGymaoaw4/O6L3SlTkoH4hgp4MpDV6N/So/@Ysq9eOu3/UXsHjP61/kzZoPq5xrv9XEjZT8T71bpQ@0wserMSbgOvwC "PHP – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=sum,reduce -pa`, ~~51~~ 50 bytes
```
say+($\=reduce{$a=$a/2+$b/2}@F)-($_=(sum@F)/@F.$/)
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJbQyXGtig1pTQ5tVol0VYlUd9IWyVJ36jWwU1TV0Ml3lajuDQXyNZ3cNNT0df8/99QRwGCTMDITEfBAowsgehffkFJZn5e8X9dX1M9A0MDIO2TWVxiZRVakpljCzRIB2LTf92CRAA "Perl 5 – Try It Online")
Output format is
```
trend
traditional
progressive
```
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 19 bytes
```
psJr{.+2./}javq.-c!
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/oNirqFpP20hPvzYrsaxQTzdZ8f9/YwMDPQMFIzBpCCIB "Burlesque – Try It Online")
Takes input of the form `300.0 200.0 100.0`. If we didn't have to print the other values would be 3 bytes shorter (i.e. Without the continuation).
Returns progressive mean™, arithmetic mean, trend
```
ps    # Parse list to array
J     # Duplicate
r{    # Reduce by (Progressive Mean)
  .+  # Adding
  2./ # Dividing by 2
}
jav   # Calulcate regular mean
q.-   # Quoted (boxed) subtract {.-}
c!    # On a non-destructive stack
```
[Answer]
# [Python 3.8](https://docs.python.org/3/index.html), 91 bytes
I wanted to flatten the recursive relation, and I got this:
```
lambda l:(m:=sum(l)/(n:=len(l)),(p:=sum(l[-i]/2**i for i in range(1,n))+l[0]/2**(n-1)),p-m)
```
[Try it online!](https://tio.run/##VcvBCsIwDAbgu0@RYzI71q4XGfRJ5g4TVy20WenmwaevtYiwQ37C9yfxvT9X1peYsgUD1@zncLvP4AcMg9leAT11yIPxC5eVBMYfj62bur5pHNg1gQPHkGZ@LKgEE539KGuN3KryFttAOSbHO1oclYBegJ6ITn/T1dTBlCxYRsvjqaxeQslvkz8 "Python 3.8 (pre-release) – Try It Online")
The use of `range` instead of the list itself makes it much longer.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 54 bytes
```
->x{a=x.sum/x.size;b=x.inject{|a,b|a/2+b/2};[a,b,b-a]}
```
[Try it online!](https://tio.run/##dZBNTsMwEEb3OUUkNiDiif8dqyoXqbpwqlYqKgi1VCq0PXuw44ljg/BinHH05vnz8dx/Dbt6OZCXy9UtL3A6v7W@7r@3i963@/fX7ebzenNNf3Mtf@5bfl@sfNf0xK3vw0e9g407HB5XDGhT81AE0PVT9RCaeMZV2Knfq2oGRAJYCTAwI0B@EyzOG6ugE0RRw0HFiaWFIhRH0xlDjgXZqAvX/KtjE4mgRE6gj5hSKMPhWGwoHQbEL51@sDy5Anw@zTtLdXwwwkEaRq0w0sali@vlU1Apk6NLxWLJRR0okTwCZGwoLplrbBllTjEL2X95mA/AtZryCB/PCJnlGX4A "Ruby – Try It Online")
Takes a list of numbers in the format `[1.0, 2.0, 3.0]`
and returns an array containing the mean, progressive-mean, and trend, respectively.
[Answer]
# [Haskell](https://www.haskell.org/), 58 bytes
```
s!p=(s,p,p-s)
f x=(sum x/sum[1|_<-x])!foldl1(((/2).).(+))x
```
[Try it online!](https://tio.run/##bY7BCoMwEETvfsUKPSQ0xkSlKNQvESmClUqjhqaFHPrv6Zq0l2pYBnZn3pBbZ@5XpZwzsa6JYZrpxNBoAIvbawKbojbyfTkntqXxsKheSUJImlFOOTlSat3UjTPU0C8R4NOPcX7CAQZoJBcMslVyLtp/N0ePgdzc5QqtzA4ivIcihdgFZTA3XsEAp2JQou315Fe5@4Nw90jhk6UfzFebcPWrDZ0B@Ta07gM "Haskell – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), 144 122 bytes
```
let f=|y:&[f64]|{let m=y.iter().sum::<f64>()/y.len()as f64;let pm=y[1..].iter().fold(y[0],|acc,x|(acc+x)/2.);(m,pm,pm-m)};
```
Straightforward approach. Shaved 22 bytes thanks SirBogman, and thanks Mabel for showing TIO's Rust support.
[Try it online!](https://tio.run/##jY1fa4MwFMXf9yliH8oNS28b@2etrtsHkTDEJiAY50xaKupnd9E1bA@jFHK4l3PP76Q@Gzuokug0L4GSdiikJerYNdE8UbuN6NrR0McGcytroGjOOope3ekN6LLBQjosNcQZ8ZisXDThiMLn1WdxgiZZCdalWcauHbjxfKXLEGkMmlXjW2jax0NqjKzth/wKQMH8IrMgWSMLkXEUlBFwG@H4smVkscJwS2n89A/CJ2T9i4Quy4gnqjovbVEGMGuj937GiOc2Ljrq4LSffvqZu5vHJ4m7HYc/vGd9L3@w43bvh28 "Rust – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), ~~116~~ 115 bytes
```
v->{float m=0,p=0;for(int i=0;i<a.length;i++){m+=a[i];p+=a[i];p=i!=0?p/2:p;}m/=a.length;return m+"\n"+p+"\n"+(p-m);
```
[Try it online!](https://tio.run/##TU67boNAEOz9FRtXIOBMnC7nc7p0qVw6Li4YyJJ76ViQLMS3k3MAK9PM7sxodxrZy6y5/kyonfUETdhZR6hY1ZmC0Br2vgx847ovhQUUSrYtfEg0MGwgYNFbkhSot3gFHdzoRB5Nfb6A9HUbL@E7KmUl3XUQMDyn@zx9yUf@sNePhyWXzoeOUIGY@uw4/OmgRZ46kfPK@ggNAYYZD5Kp0tT0zTFJ4kEnQp7xwt3KAp9E/uZ2@1fHR70Tj7gvqfMGdLL9NNvEzRS5TMd8Wov963i6tVRqZjtiLpQjZaKKSefULZJxPOfGzTj9Ag "Java (JDK) – Try It Online")
[Answer]
# [Factor](https://factorcode.org/), 48 bytes
```
[ [ unclip [ + 2 / ] reduce ] keep mean 2dup - ]
```
[Try it online!](https://tio.run/##TY/BTsMwEETv@YpRJU4IsBNUJfABiAsXxKn0YLmb1mrjGHt9QFW/PWysKtTrw@y@mZXdG8tjnL4@3z/eXpDoJ5O3lDAYPuBI0dOp6MfEhl1iZxNCJObfEJ1n9GMUzM7v8VpV5wpyztCo0eBy7Rrp9NJphVqhUf9YzRMlQN2adBktk2epDq0sarEWpW9Xlpoda6Gt0G5hXUnNmZnra@4ybbBB9vbkgoh7eeETtoi0y5ZEHIkCBjIe9S4HPGArgdVdRrnffoXy/V6sdhzCmAhk7GH6Aw "Factor – Try It Online")
[Answer]
# [Arturo](https://arturo-lang.io), 57 bytes
```
$[b][a:average b@[p:fold.seed:b\0b[x y][//x+y 2]a p p-a]]
```
[Try it](http://arturo-lang.io/playground?AGxlmX)
[Answer]
# [Scala](https://www.scala-lang.org/), 126 bytes
Golfed version. [Try it online!](https://tio.run/##TcvNSsQwFAXg/TzFcZhFgp0fZRBtzGI27nwCdXFtE40k6SUJQSl99jp0EITvcDkHbu7I0zy8f5mu4JlchPkuJvYZJ2aMK6CSB7U4pUQ/L09@oPIGfaniocHZ/eKuwXFxcyHn3lhYUdv/r1KPlRJCw@0y6IOyQxLucVt3LvauM1mO4VpX4aTiv6udFe5KHyTvb2F8NmA1qbDXdedN/CifKq834TVu@JyRt2FaTzPAycXio7CCpFxN8y8)
```
def f(v:Array[Float])={var m,p:Float=0;for(i<-v.indices){m+=v(i);p+=v(i);p=if(i!=0)p/2 else p;};m/=v.length;s"$m\n$p\n${p-m}"}
```
Ungolfed version. [Try it online!](https://tio.run/##ZY4/a8MwFMR3fYqrySBR509LKa1pAlmyZcrYdlAcOVWRZSEJkxD82Z1n2VML94bfe3cnhVIa2ffN8VeVEXupLdQlKnsK2DqHGwNaaSALbL2X18@daWT8xnpE/p6D9Jb0muMl6WmUmLLV3@wGh@i1PVNLO9DwyGD1qHO4AslHx1XaV40H1/iYo11oe9KlCmKKADUeqYRrMbH7x2voasg/UJ8gXuIZygQFlywdG2uWFFsYZc/xJ21CNqu/7MzR3BzmqLuMjW5HX4/G8opLIVjH@v4O)
```
object Main extends App {
  val a: Array[Float] = Array(9, 9, 8, 8, 6, 4, 4, 1, 1, 1)
  val f: Array[Float] => String = v => {
    var m, p: Float = 0
    for (i <- v.indices) {
      m += v(i)
      p += v(i)
      p = if (i != 0) p / 2 else p
    }
    m /= v.length
    s"$m\n$p\n${p - m}"
  }
  println(f(a))
}
```
]