#include <cstdio>
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <ctime>
#include <cstring>
#include <cassert>
#include <bitset>
#include <sstream>

using namespace std;

#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; i--)
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define last(a) int(a.size() - 1)
#define all(a) a.begin(), a.end()
#define seta(a,x) memset (a, x, sizeof (a))
#define I (int)

typedef long long int64;
typedef pair <int, int> pii;
typedef long double ldb;

const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const int64 inf64 = ((int64)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
const string task = "";

template <class T> T sqr (T x) {return x * x;}

const int nmax = 300300;

int n, l , v1, v2;
int a[nmax];
long double res[nmax];

int main ()
{
    cin >> n >> l >> v1 >> v2;
    forn(i, n)
        scanf("%d", &a[i]);
    forn(i, n)
        a[i + n] = a[i] + 2 * l;
    a[2 * n] = 1e10;

    long double len = 1.0 * v2 * l / (v1 + v2);
    vector<double> st;
    forn(i, n * 2){
        st.pb(a[i]);
        st.pb(fmod(a[i] - len + 2 * l, 2 * l));
    }
    st.pb(0);
    st.pb(len);
    st.pb(2 * l - len);
    forn(i, st.size())
        st[i] = fmod(st[i] + 4 * l, 2 * l);
    sort(all(st));
    st.pb(2 * l);
    int p1, p2;
    p1 = p2 = 0;
    forn(i, st.size()-1){
        while (a[p1] < st[i] + 1e-5)
            p1 ++;
        p2 = max(p2, p1-1);
        while (a[p2 + 1] - st[i] < len + 1e-5)
            p2 ++;
        res[p2-p1 + 1] += st[i+1] - st[i];
//      cerr << st[i] << " " << st[i+1] << " " << p1 << " " << p2 << endl;
    }
    forn(i, n + 1)
        printf("%0.15lf\n", (double)res[i] / (2 * l));

    return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <ctime>
#include <cstring>
#include <cassert>
#include <bitset>
#include <sstream>

using namespace std;

#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; i--)
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define last(a) int(a.size() - 1)
#define all(a) a.begin(), a.end()
#define seta(a,x) memset (a, x, sizeof (a))
#define I (int)

typedef long long int64;
typedef pair <int, int> pii;
typedef long double ldb;

const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const int64 inf64 = ((int64)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
const string task = "";

template <class T> T sqr (T x) {return x * x;}

const int nmax = 300300;

int n;
long double l , v1, v2;
long double res[nmax], a[nmax];

int main ()
{
    cin >> n >> l >> v1 >> v2;
    forn(i, n) {
         int x;
        scanf("%d", &x);
        a[i] = x;
        a[n + i] = x + 2. * l;
    }
    a[2 * n] = 1e10;

    long double len = 1.0 * v2 * l / (v1 + v2);
    vector<long double> st;
    forn(i, n * 2){
        st.pb(a[i]);
        st.pb(a[i] + len);
        st.pb(a[i] - len);
    }
    st.pb(0);
    st.pb(len);
    st.pb(2 * l - len);
    forn(i, st.size()){
        while (st[i] < 0)
            st[i] += 2 * l;
        while (st[i] >= 2 * l)
            st[i] -= 2 * l;
    }
    sort(all(st));
    int m = 1;
    for (int i = 1; i < st.size(); i ++)
        if (st[i] - st[m-1] > 1e-10){
            st[m] = st[i];
            m ++;
        }
    st.resize(m);
    st.pb(2. * l);
    int p1, p2;
    p1 = p2 = 0;
    forn(i, st.size()-1){
        long double mid = (st[i] + st[i+1]) / 2.;
        while (a[p1] < mid)
            p1 ++;
        p2 = max(p2, p1-1);
        while (a[p2 + 1] - mid < len)
            p2 ++;
        res[p2-p1 + 1] += st[i+1] - st[i];
    }
    forn(i, n + 1)
        printf("%0.15lf\n", (double)(res[i] / (2. * l)));

    return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <ctime>
#include <cstring>
#include <cassert>
#include <bitset>
#include <sstream>

using namespace std;

#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; i--)
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define last(a) int(a.size() - 1)
#define all(a) a.begin(), a.end()
#define seta(a,x) memset (a, x, sizeof (a))
#define I (int)

typedef long long int64;
typedef pair <int, int> pii;
typedef long double ldb;

const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const int64 inf64 = ((int64)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
const string task = "";

template <class T> T sqr (T x) {return x * x;}

const int nmax = 300300;

int n;
long double l , v1, v2;
long double res[nmax], a[nmax];

int main ()
{
    cin >> n >> l >> v1 >> v2;
    forn(i, n) {
         int x;
        scanf("%d", &x);
        a[i] = x;
        a[n + i] = x + 2. * l;
    }
    a[2 * n] = 1e10;

    long double len = 1.0 * v2 * l / (v1 + v2);
    vector<long double> st;
    forn(i, n * 2){
        st.pb(a[i]);
        st.pb(a[i] - len);
    }
    st.pb(0);
    st.pb(len);
    st.pb(2 * l - len);
    forn(i, st.size())
        st[i] = fmod(st[i] + 10. * l, 2. * l);
    sort(all(st));
    st.pb(2. * l);
    int p1, p2;
    p1 = p2 = 0;
    forn(i, st.size()-1){
        long double mid = (st[i] + st[i+1]) / 2.;
        while (a[p1] < mid)
            p1 ++;
        p2 = max(p2, p1-1);
        while (a[p2 + 1] - mid < len)
            p2 ++;
        res[p2-p1 + 1] += st[i+1] - st[i];
    }
    forn(i, n + 1)
        printf("%0.15lf\n", (double)(res[i] / (2. * l)));

    return 0;
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <ctime>
#include <cstring>
#include <cassert>
#include <bitset>
#include <sstream>

using namespace std;

#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; i--)
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define last(a) int(a.size() - 1)
#define all(a) a.begin(), a.end()
#define seta(a,x) memset (a, x, sizeof (a))
#define I (int)

typedef long long int64;
typedef pair <int, int> pii;
typedef long double ldb;

const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const int64 inf64 = ((int64)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
const string task = "";

template <class T> T sqr (T x) {return x * x;}

const int nmax = 300300;

int n;
long double l , v1, v2;
long double res[nmax], a[nmax];

int main ()
{
    cin >> n >> l >> v1 >> v2;
    forn(i, n) {
         int x;
        scanf("%d", &x);
        a[i] = x;
        a[n + i] = x + 2. * l;
    }
    a[2 * n] = 1e10;

    long double len = 1.0 * v2 * l / (v1 + v2);
    vector<long double> st;
    forn(i, n * 2){
        st.pb(a[i]);
        st.pb(a[i] + len);
        st.pb(a[i] - len);
    }
    st.pb(0);
    st.pb(len);
    st.pb(2 * l - len);
    forn(i, st.size()){
        while (st[i] < 0)
            st[i] += 2 * l;
        while (st[i] >= 2 * l)
            st[i] -= 2 * l;
    }
    sort(all(st));
    int m = 1;
    for (int i = 1; i < st.size(); i ++)
        if (st[i] - st[m-1] > 1e-10){
            st[m] = st[i];
            m ++;
        }
    st.resize(m);
    st.pb(2. * l);
    int p1, p2;
    p1 = 0;
    p2 = -1;
    forn(i, st.size()-1){
        long double mid = (st[i] + st[i+1]) / 2.;
        while (a[p1] < mid)
            p1 ++;
        p2 = max(p2, p1-1);
        while (a[p2 + 1] - mid < len)
            p2 ++;
        res[p2-p1 + 1] += st[i+1] - st[i];
    }
    forn(i, n + 1)
        printf("%0.15lf\n", (double)(res[i] / (2. * l)));

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#define mp make_pair
#define pb push_back
#define pii pair<double,int>
using namespace std;
int n,l,v1,v2,cnt,tot,a[100010];
pii p[200010];
double ans[100010],ti;
int main(){
    scanf("%d%d%d%d",&n,&l,&v1,&v2);
    for(int i=1;i<=n;++i)scanf("%d",&a[i]);
    double ll=l-(double)l*v1/(v1+v2);
    for(int i=1;i<=n;++i){
        if(a[i]<=ll)++cnt;
        if(a[i]>ll){
            p[++tot]=mp((l*2-a[i])/(double)v1,1);
            p[++tot]=mp((l*2-a[i]+ll)/(double)v1,-1);
        }
        else{
            p[++tot]=mp((ll-a[i])/(double)v1,-1);
            p[++tot]=mp((l*2-a[i])/(double)v1,1);
        }
    }
    sort(p+1,p+tot+1);ti=(2*l)/(double)v1;
    for(int i=1;i<=tot;++i){
        ans[cnt]+=(p[i].first-p[i-1].first)/ti;
        cnt+=p[i].second;
    }
    ans[cnt]+=(ti-p[tot].first)/ti;
    for(int i=0;i<=n;++i)
        printf("%.10lf\n",ans[i]);
    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#define mp make_pair
#define pb push_back
#define pii pair<double,int>
using namespace std;
int n,l,v1,v2,cnt,tot,a[100010];
pii p[100010];
double ans[100010],ti;
int main(){
    scanf("%d%d%d%d",&n,&l,&v1,&v2);
    for(int i=1;i<=n;++i)scanf("%d",&a[i]);
    double ll=l-(double)l*v1/(v1+v2);
    for(int i=1;i<=n;++i){
        if(a[i]<=ll)++cnt;
        if(a[i]>ll){
            p[++tot]=mp((l*2-a[i])/(double)v1,1);
            p[++tot]=mp((l*2-a[i]+ll)/(double)v1,-1);
        }
        else{
            p[++tot]=mp((ll-a[i])/(double)v1,-1);
            p[++tot]=mp((l*2-a[i])/(double)v1,1);
        }
    }
    sort(p+1,p+tot+1);ti=(2*l)/(double)v1;
    for(int i=1;i<=tot;++i){
        ans[cnt]+=(p[i].first-p[i-1].first)/ti;
        cnt+=p[i].second;
    }
    ans[cnt]+=(ti-p[tot].first)/ti;
    for(int i=0;i<=n;++i)
        printf("%.10lf\n",ans[i]);
    return 0;
}


#pragma comment(linker, "/STACK:64000000")
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <ctime>
#include <deque>

#define forn(i, n) for (int i = 0; i < int(n); i ++)
#define ford(i, n) for (int i = int(n) - 1; i >= 0; i --)
#define mp make_pair
#define pb push_back
#define fs first
#define sc second
#define pi 3.1415926535897932
#define ll long long
#define ld long double

using namespace std;

struct item{
    ld x;
    int cost;
};

item b[400100];
int a[200100];
ld ans[100100];
int sz = 0;
ld eps = 1e-10;

inline bool cmp(const item& a, const item& b){
    return (a.x - b.x < eps);
}

int main(){
//  freopen ("input.txt","rt",stdin);
//  freopen ("output.txt","wt",stdout);
    ll n, l, v1, v2;
    cin >> n >> l >> v1 >> v2;
    forn(i, n){
        cin >> a[i + 1];
    }
    a[0] = 0;
    n ++;
    int n1 = n;
    for (int i = n; i < 2 * n; i ++)
        a[i] = a[i - n] + 2 * l;
    n *= 2;
    ld ln = 1.0 * v2 * l / (1.0 * v1 + v2);
    forn(i, n){
        b[sz ++].x = a[i];
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = -1;
    }
    forn(i, n){
        b[sz ++].x = 1.0 * a[i] - ln;
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = 1;
    }
    sort(b, b + sz, cmp);
    int t = 0, cost = 0;
    while (b[t].x < eps){
        cost += b[t].cost;
        t ++;
    }
    for (int i = t; i < sz; i ++){
        if (b[i].x - 2 * l > eps) break;
        ans[cost] += b[i].x - b[i - 1].x;
        cost += b[i].cost;
    }
    forn(i, n1)
        printf ("%0.20f\n", (double)ans[i] / (2.0 * l));
    return 0;
}


#pragma comment(linker, "/STACK:64000000")
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <ctime>
#include <deque>

#define forn(i, n) for (int i = 0; i < int(n); i ++)
#define ford(i, n) for (int i = int(n) - 1; i >= 0; i --)
#define mp make_pair
#define pb push_back
#define fs first
#define sc second
#define pi 3.1415926535897932
#define ll long long
#define ld long double

using namespace std;

struct item{
    ld x;
    int cost;
};

item b[400100];
ld a[200100];
ld ans[100100];
int sz = 0;
ld eps = 1e-6;

inline bool cmp(const item& a, const item& b){
    return (a.x - b.x < eps);
}

int main(){
//  freopen ("input.txt","rt",stdin);
//  freopen ("output.txt","wt",stdout);
    ll n, l, v1, v2;
    cin >> n >> l >> v1 >> v2;
    forn(i, n){
        cin >> a[i + 1];
    }
    a[0] = 0;
    n ++;
    int n1 = n;
    for (int i = n; i < 2 * n; i ++)
        a[i] = a[i - n] + 2 * l;
    n *= 2;
    ld ln = 1.0 * v2 * l / (1.0 * v1 + v2);
    forn(i, n){
        b[sz ++].x = a[i];
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = -1;
    }
    forn(i, n){
        b[sz ++].x = 1.0 * a[i] - ln;
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = 1;
    }
    sort(b, b + sz, cmp);
    int t = 0, cost = 0;
    while (b[t].x < eps){
        cost += b[t].cost;
        t ++;
    }
    for (int i = t; i < sz; i ++){
        if (b[i].x - 2.0 * l > eps) break;
        ans[cost] += b[i].x - b[i - 1].x;
        cost += b[i].cost;
    }
    forn(i, n1)
        printf ("%0.20f\n", (double)ans[i] / (2.0 * l));
    return 0;
}


#pragma comment(linker, "/STACK:64000000")
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <ctime>
#include <deque>

#define forn(i, n) for (int i = 0; i < int(n); i ++)
#define ford(i, n) for (int i = int(n) - 1; i >= 0; i --)
#define mp make_pair
#define pb push_back
#define fs first
#define sc second
#define pi 3.1415926535897932
#define ll long long
#define ld long double

using namespace std;

struct item{
    ld x;
    int cost;
};

item b[400100];
int a[200100];
ld ans[100100];
int sz = 0;
ld eps = 1e-8;

inline bool cmp(const item& a, const item& b){
    return (a.x - b.x < eps);
}

int main(){
//  freopen ("input.txt","rt",stdin);
//  freopen ("output.txt","wt",stdout);
    ll n, l, v1, v2;
    cin >> n >> l >> v1 >> v2;
    forn(i, n){
        cin >> a[i + 1];
    }
    a[0] = 0;
    n ++;
    int n1 = n;
    for (int i = n; i < 2 * n; i ++)
        a[i] = a[i - n] + 2 * l;
    n *= 2;
    ld ln = 1.0 * v2 * l / (1.0 * v1 + v2);
    forn(i, n){
        b[sz ++].x = a[i];
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = -1;
    }
    forn(i, n){
        b[sz ++].x = 1.0 * a[i] - ln;
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = 1;
    }
    sort(b, b + sz, cmp);
    int t = 0, cost = 0;
    while (b[t].x < eps){
        cost += b[t].cost;
        t ++;
    }
    for (int i = t; i < sz; i ++){
        if (b[i].x - 2 * l > eps) break;
        ans[cost] += b[i].x - b[i - 1].x;
        cost += b[i].cost;
    }
    forn(i, n1)
        printf ("%0.20f\n", (double)ans[i] / (2.0 * l));
    return 0;
}


#pragma comment(linker, "/STACK:64000000")
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <ctime>
#include <deque>

#define forn(i, n) for (int i = 0; i < int(n); i ++)
#define ford(i, n) for (int i = int(n) - 1; i >= 0; i --)
#define mp make_pair
#define pb push_back
#define fs first
#define sc second
#define pi 3.1415926535897932
#define ll long long
#define ld long double

using namespace std;

struct item{
    ld x;
    int cost;
};

item b[400100];
int a[200100];
ld ans[100100];
int sz = 0;
ld eps = 1e-6;

inline bool cmp(const item& a, const item& b){
    return (a.x - b.x < eps);
}

int main(){
//  freopen ("input.txt","rt",stdin);
//  freopen ("output.txt","wt",stdout);
    ll n, l, v1, v2;
    cin >> n >> l >> v1 >> v2;
    forn(i, n){
        cin >> a[i + 1];
    }
    a[0] = 0;
    n ++;
    int n1 = n;
    for (int i = n; i < 2 * n; i ++)
        a[i] = a[i - n] + 2 * l;
    n *= 2;
    ld ln = 1.0 * v2 * l / (1.0 * v1 + v2);
    forn(i, n){
        b[sz ++].x = a[i];
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = -1;
    }
    forn(i, n){
        b[sz ++].x = 1.0 * a[i] - ln;
        if (i == 0 || i == n1) b[sz - 1].cost = 0;
        else b[sz - 1].cost = 1;
    }
    sort(b, b + sz, cmp);
    int t = 0, cost = 0;
    while (b[t].x < eps){
        cost += b[t].cost;
        t ++;
    }
    for (int i = t; i < sz; i ++){
        if (b[i].x - 2 * l > eps) break;
        ans[cost] += b[i].x - b[i - 1].x;
        cost += b[i].cost;
    }
    forn(i, n1)
        printf ("%0.20f\n", (double)ans[i] / (2.0 * l));
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <vector>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
#include <sstream>
using namespace std;

#define f first
#define s second
#define mp make_pair
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define forit(it,S) for(typeof(S.begin()) it = S.begin(); it != S.end(); ++it)

const int maxn = 100000;
int n, l, v1, v2, bn;
double a[maxn + 100];
double b[333333];
double res[111111];

int calc(double l, double r) {
	int p1 = lower_bound(a, a + n, l) - a;
	int p2 = lower_bound(a, a + n, r) - a - 1;
	return max(0, p2 - p1 + 1);
}

int main() {
	scanf("%d%d%d%d", &n, &l, &v1, &v2);
	for (int i = 0; i < n; ++i) {
		int x;
		scanf("%d", &x);
		a[i] = x;
	}
	double d = (1.0 * l / (v1 + v2)) * v2;
	//printf("d=%.10lf\n", d);
	b[bn++] = 0.0;
	b[bn++] = 2.0 * l;
	for (int i = 0; i < n; ++i) {
		b[bn++] = a[i];
		b[bn++] = a[i] - d;
		if (b[bn - 1] < -1e-9)
			b[bn - 1] += 2 * l;
	}
	sort(b, b + bn);
	/*for (int i = 0; i < bn; ++i)
		printf("%.2lf ", b[i]);
	puts("");	*/
	for (int i = 0; i < bn - 1; ++i) {
		double x = (b[i] + b[i + 1]) / 2;
		int k = calc(x, min(x + d, 2.0 * l));
		if (x + d > 2 * l)
			k += calc(0, x + d - 2 * l);
		res[k] += b[i + 1] - b[i];
		//printf("%.2lf %d\n", x, k);
	}
	for (int i = 0; i <= n; ++i)
		printf("%.15lf\n", res[i] / (2.0 * l));
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <vector>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
#include <sstream>
using namespace std;

#define f first
#define s second
#define mp make_pair
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define forit(it,S) for(typeof(S.begin()) it = S.begin(); it != S.end(); ++it)

const long long inf = (1LL << 32);
int n;
long long l, v1, v2;
long long a[222222];
long long ans[111111];

int main() {
	cin >> n >> l >> v1 >> v2;
	for (int i = 0; i < n; ++i) {
		int x;
		scanf("%d", &x);
		a[i] = x;
		a[n + i] = x + 2 * l;
	}
	a[2 * n] = inf;

	long long d = l * v2;
	long long pos = 0;
	int p1 = 0, p2 = 0;
	while (a[p2] * (v1 + v2) <= d)
		++p2;
	while (pos < l * 2 * (v1 + v2)) {
		//cout << pos << " " << a[p1] * (v1 + v2) << " " << a[p2] * (v1 + v2) << endl;
		long long dx = min(a[p2] * (v1 + v2) - d - pos, a[p1] * (v1 + v2) - pos);
		dx = min(dx, 2 * l * (v1 + v2) - pos);
		ans[p2 - p1] += dx;
		pos += dx;
		if (a[p2] * (v1 + v2) <= pos + d)
			++p2;
		if (a[p1] * (v1 + v2) <= pos)
			++p1;
	}
	for (int i = 0; i <= n; ++i)
		printf("%.15lf\n", ans[i] / (2.0 * l * (v1 + v2)));
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <vector>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
#include <sstream>
using namespace std;

#define f first
#define s second
#define mp make_pair
#define sz(a) int((a).size())
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define forit(it,S) for(typeof(S.begin()) it = S.begin(); it != S.end(); ++it)

const int maxn = 100000;
int n, l, v1, v2, bn;
double a[maxn + 100];
double b[333333];
double res[111111];

int calc(double l, double r) {
	int p1 = lower_bound(a, a + n, l) - a;
	int p2 = lower_bound(a, a + n, r) - a - 1;
	return max(0, p2 - p1 + 1);
}

int main() {
	scanf("%d%d%d%d", &n, &l, &v1, &v2);
	for (int i = 0; i < n; ++i) {
		int x;
		scanf("%d", &x);
		a[i] = x;
	}
	double d = (1.0 * l / (v1 + v2)) * v2;
	//printf("d=%.10lf\n", d);
	b[bn++] = 0.0;
	b[bn++] = 2.0 * l;
	for (int i = 0; i < n; ++i) {
		b[bn++] = a[i];
		b[bn++] = a[i] - d;
		if (b[bn - 1] < -1e-9)
			b[bn - 1] += 2 * l;
	}
	sort(b, b + bn);
	/*for (int i = 0; i < bn; ++i)
		printf("%.2lf ", b[i]);
	puts("");	*/
	for (int i = 0; i < bn - 1; ++i) {
		double x = b[i];
		int k = calc(x, min(x + d, 2.0 * l));
		if (x + d > 2 * l)
			k += calc(0, x + d - 2 * l);
		res[k] += b[i + 1] - b[i];
	}
	for (int i = 0; i <= n; ++i)
		printf("%.15lf\n", res[i] / (2.0 * l));
	return 0;
}


// Headers {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define REP(i,n) for(int i=0; i<(n); ++i)
#define FOR(i,j,k) for(int i=(j); i<=(k); ++i)
#define FORD(i,j,k) for(int i=(j); i>=(k); --i)
#define FOREACH(it,c) for(typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ST first
#define ND second
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define SQR(a) ((a)*(a))
#define debug(x) cerr << #x << " = " << x << '\n'
template<typename Q> inline int size(Q a) { return a.size(); }
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<pair<int,int> > VPII;
typedef unsigned long long ULL;
typedef long long LL;
typedef long double LD;
typedef pair<int,int> PII;
const int INF=1000000000;
// }}}

const int EPS = 1e-9;

bool isZero(double x) {
  return -EPS < x && x < EPS;
}
const int MX = 100005;

int n;
double l, v1, v2;
double a[MX];

double res[MX];

vector<pair<double, double> > vsb;
vector<pair<double, int> > events;

int main() {
  scanf("%d%lf%lf%lf", &n, &l, &v1, &v2);
  REP(i, n) scanf("%lf", &a[i]);
  double crit = v2*l/(v1+v2);
  double T = 2*l/v1;
  REP(i, n) {
    // blizej niz krytyczna
    vsb.push_back(MP(0.0, max(0.0, (crit-a[i])/v1)));
    // czekamy, az dojdzie do 0.0 i liczymy czas do krytycznej
    vsb.push_back(MP(min(T, (2*l-a[i])/v1), min(T, (2.0*l-a[i]+crit)/v1)));
  }
  REP(i, vsb.size()) {
    // printf("(%lf, %lf)\n", vsb[i].ST, vsb[i].ND);
    events.push_back(MP(vsb[i].ST, 1));
    events.push_back(MP(vsb[i].ND, -1));
  }
  sort(events.begin(), events.end());
  int cur = 0;
  REP(i, events.size()) {
    // printf("%lf -> %d\n", events[i].ST, events[i].ND);
    if(isZero(events[i].ST-T)) break;
    double prev = (i>0) ? events[i-1].ST : 0.0;
    if(cur>=0 && cur<=n) res[cur] += (events[i].ST - prev);
    // printf("%d += %lf\n", cur, events[i].ST-prev);
    cur += events[i].ND;
  }
  res[cur] += (T - events.back().ST);
  REP(i, n+1) printf("%.15lf\n", res[i]/T);
  return 0;
}


// Headers {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define REP(i,n) for(int i=0; i<(n); ++i)
#define FOR(i,j,k) for(int i=(j); i<=(k); ++i)
#define FORD(i,j,k) for(int i=(j); i>=(k); --i)
#define FOREACH(it,c) for(typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ST first
#define ND second
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define SQR(a) ((a)*(a))
#define debug(x) cerr << #x << " = " << x << '\n'
template<typename Q> inline int size(Q a) { return a.size(); }
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<pair<int,int> > VPII;
typedef unsigned long long ULL;
typedef long long LL;
typedef long double LD;
typedef pair<int,int> PII;
const int INF=1000000000;
// }}}

const int EPS = 1e-9;

bool isZero(double x) {
  return -EPS < x && x < EPS;
}
const int MX = 100005;

int n;
double l, v1, v2;
double a[MX];

double res[MX];

vector<pair<double, double> > vsb;
vector<pair<double, double> > events;

int main() {
  scanf("%d%lf%lf%lf", &n, &l, &v1, &v2);
  REP(i, n) scanf("%lf", &a[i]);
  double crit = v2*l/(v1+v2);
  double T = 2*l/v1;
  REP(i, n) {
    // blizej niz krytyczna
    vsb.push_back(MP(0.0, max(0.0, (crit-a[i])/v1)));
    // czekamy, az dojdzie do 0.0 i liczymy czas do krytycznej
    vsb.push_back(MP(min(T, (2*l-a[i])/v1), min(T, (2.0*l-a[i]+crit)/v1)));
  }
  REP(i, vsb.size()) {
    events.push_back(MP(vsb[i].ST, 1));
    events.push_back(MP(vsb[i].ND, -1));
  }
  sort(events.begin(), events.end());
  int cur = 0;
  REP(i, events.size()) {
    if(isZero(events[i].ST-T)) break;
    double prev = (i>0) ? events[i-1].ST : 0.0;
    res[cur] += (events[i].ST - prev);
    cur += events[i].ND;
  }
  REP(i, n+1) printf("%.15lf\n", res[i]/T);
  return 0;
}


// Headers {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define REP(i,n) for(int i=0; i<(n); ++i)
#define FOR(i,j,k) for(int i=(j); i<=(k); ++i)
#define FORD(i,j,k) for(int i=(j); i>=(k); --i)
#define FOREACH(it,c) for(typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ST first
#define ND second
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define SQR(a) ((a)*(a))
#define debug(x) cerr << #x << " = " << x << '\n'
template<typename Q> inline int size(Q a) { return a.size(); }
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<pair<int,int> > VPII;
typedef unsigned long long ULL;
typedef long long LL;
typedef long double LD;
typedef pair<int,int> PII;
const int INF=1000000000;
// }}}

const int EPS = 1e-9;

bool isZero(double x) {
  return -EPS < x && x < EPS;
}
const int MX = 100005;

int n;
double l, v1, v2;
double a[MX];

double res[MX];

vector<pair<double, double> > vsb;
vector<pair<double, int> > events;

int main() {
  scanf("%d%lf%lf%lf", &n, &l, &v1, &v2);
  REP(i, n) scanf("%lf", &a[i]);
  double crit = v2*l/(v1+v2);
  double T = 2*l/v1;
  REP(i, n) {
    // blizej niz krytyczna
    vsb.push_back(MP(0.0, max(0.0, (crit-a[i])/v1)));
    // czekamy, az dojdzie do 0.0 i liczymy czas do krytycznej
    vsb.push_back(MP(min(T, (2*l-a[i])/v1), min(T, (2.0*l-a[i]+crit)/v1)));
  }
  REP(i, vsb.size()) {
    // printf("(%lf, %lf)\n", vsb[i].ST, vsb[i].ND);
    events.push_back(MP(vsb[i].ST, 1));
    events.push_back(MP(vsb[i].ND, -1));
  }
  sort(events.begin(), events.end());
  int cur = 0;
  REP(i, events.size()) {
    // printf("%lf -> %d\n", events[i].ST, events[i].ND);
    if(isZero(events[i].ST-T)) break;
    double prev = (i>0) ? events[i-1].ST : 0.0;
    res[cur] += (events[i].ST - prev);
    // printf("%d += %lf\n", cur, events[i].ST-prev);
    cur += events[i].ND;
  }
  res[cur] += (T - events.back().ST);
  REP(i, n+1) printf("%.15lf\n", res[i]/T);
  return 0;
}


// Headers {{{
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define REP(i,n) for(int i=0; i<(n); ++i)
#define FOR(i,j,k) for(int i=(j); i<=(k); ++i)
#define FORD(i,j,k) for(int i=(j); i>=(k); --i)
#define FOREACH(it,c) for(typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ST first
#define ND second
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define SQR(a) ((a)*(a))
#define debug(x) cerr << #x << " = " << x << '\n'
template<typename Q> inline int size(Q a) { return a.size(); }
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<pair<int,int> > VPII;
typedef unsigned long long ULL;
typedef long long LL;
typedef long double LD;
typedef pair<int,int> PII;
const int INF=1000000000;
// }}}

const int EPS = 1e-9;

bool isZero(double x) {
  return -EPS < x && x < EPS;
}
const int MX = 100005;

double n, l, v1, v2;
double a[MX];

double res[MX];

vector<pair<double, double> > vsb;
vector<pair<double, double> > events;

int main() {
  scanf("%lf%lf%lf%lf", &n, &l, &v1, &v2);
  REP(i, n) scanf("%lf", &a[i]);
  double crit = v2*l/(v1+v2);
  double T = 2*l/v1;
  REP(i, n) {
    // blizej niz krytyczna
    vsb.push_back(MP(0.0, max(0.0, (crit-a[i])/v1)));
    // czekamy, az dojdzie do 0.0 i liczymy czas do krytycznej
    vsb.push_back(MP(min(T, (2*l-a[i])/v1), min(T, (2.0*l-a[i]+crit)/v1)));
  }
  REP(i, vsb.size()) {
    events.push_back(MP(vsb[i].ST, 1));
    events.push_back(MP(vsb[i].ND, -1));
  }
  sort(events.begin(), events.end());
  int cur = 0;
  REP(i, events.size()) {
    if(isZero(events[i].ST-T)) break;
    double prev = (i>0) ? events[i-1].ST : 0.0;
    res[cur] += (events[i].ST - prev);
    cur += events[i].ND;
  }
  REP(i, n+1) printf("%.15lf\n", res[i]/T);
  return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

struct node {
	double x;
	int sta;
};

int n,l,v1,v2;
double cnt[100010];
int a[100010];
node b[200010];

bool cmp(const node &a,const node &b) {
	return a.x<b.x;
}

int main() {
	//freopen("c.in","r",stdin);

	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;++i) scanf("%d",&a[i]);
	sort(a,a+n);
	double l1=(double)l/(double)(v1+v2)*(double)v2;
	for (int i=0;i<n;++i) {
		b[2*i].sta=-1; b[2*i].x=a[i];
		b[2*i+1].sta=1; b[2*i+1].x=a[i]-l1;
		if (a[i]-l1<0) b[2*i+1].x+=2*l;
	}

	sort(b,b+2*n,cmp);
	int ct=0;
	double last=0;
	for (int i=0;i<n;++i)
		if (a[i]<l1) ct++;
	for (int i=0;i<2*n;++i) {
		cnt[ct]+=b[i].x-last;
		last=b[i].x;
		ct+=b[i].sta;
	}
	cnt[ct]+=2*l-last;
	for (int i=0;i<=n;++i)
		printf("%.10lf\n",cnt[i]/(double)(2*l));
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

struct node {
	double x;
	int sta;
};

int n,l,v1,v2;
long double cnt[100010];
int a[100010];
node b[200010];

bool cmp(const node &a,const node &b) {
	return a.x<b.x;
}

int main() {
	//freopen("c.in","r",stdin);

	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;++i) scanf("%d",&a[i]);
	sort(a,a+n);
	long double l1=(long double)l/(long double)(v1+v2)*(long double)v2;
	for (int i=0;i<n;++i) {
		b[2*i].sta=-1; b[2*i].x=a[i];
		b[2*i+1].sta=1; b[2*i+1].x=a[i]-l1;
		if (a[i]-l1<0) b[2*i+1].x+=2*l;
	}

	sort(b,b+2*n,cmp);
	int ct=0;
	double last=0;
	for (int i=0;i<n;++i)
		if (a[i]<l1) ct++;
	for (int i=0;i<2*n;++i) {
		cnt[ct]+=b[i].x-last;
		last=b[i].x;
		ct+=b[i].sta;
	}
	cnt[ct]+=2*l-last;
	for (int i=0;i<=n;++i)
		printf("%.10lf\n",(double)(cnt[i]/(long double)(2*l)));
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

struct node {
	double x;
	int sta;
};

int n,l,v1,v2;
long double cnt[100010];
int a[100010];
node b[200010];

bool cmp(const node &a,const node &b) {
	return a.x<b.x;
}

int main() {
	//freopen("c.in","r",stdin);

	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;++i) scanf("%d",&a[i]);
	sort(a,a+n);
	double l1=(double)l/(double)(v1+v2)*(double)v2;
	for (int i=0;i<n;++i) {
		b[2*i].sta=-1; b[2*i].x=a[i];
		b[2*i+1].sta=1; b[2*i+1].x=a[i]-l1;
		if (a[i]-l1<0) b[2*i+1].x+=2*l;
	}

	sort(b,b+2*n,cmp);
	int ct=0;
	double last=0;
	for (int i=0;i<n;++i)
		if (a[i]<l1) ct++;
	for (int i=0;i<2*n;++i) {
		cnt[ct]+=b[i].x-last;
		last=b[i].x;
		ct+=b[i].sta;
	}
	cnt[ct]+=2*l-last;
	for (int i=0;i<=n;++i)
		printf("%.10lf\n",cnt[i]/(long double)(2*l));
	return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-8

int n,l,v1,v2;
int64 a[200001];
double f[100001];
vector<double> e;

int main() {
	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;i++) cin >> a[i];
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-7

int n,l,v1,v2;
int64 a[200001];
double f[100001];
vector<double> e;

int main() {
	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;i++) cin >> a[i];
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-9

int n,l,v1,v2;
int64 a[200001];
double f[100001];
vector<double> e;

int main() {
	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;i++) cin >> a[i];
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007

int n,l,v1,v2;
int a[200001];
double f[100001];
vector<double> e;

int main() {
	scanf("%d %d %d %d",&n,&l,&v1,&v2);
	for (int i=0;i<n;i++) scanf("%d",&a[i]);
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<=e1) j1++;
		while (a[j2+1]-e1<=d) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}

/*
4 2 1 2
0 1 2 3
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-12

int n,l,v1,v2;
int64 a[200001];
double f[100001];
vector<double> e;

int main() {
	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;i++) cin >> a[i];
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-11

int n,l,v1,v2;
int64 a[200001];
double f[100001];
vector<double> e;

int main() {
	cin >> n >> l >> v1 >> v2;
	for (int i=0;i<n;i++) cin >> a[i];
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}

/*
10 100 1 2
25 51 71 126 143 148 167 179 180 199
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-11

int n,l,v1,v2;
int a[200001];
double f[100001];
vector<double> e;

int main() {
	scanf("%d %d %d %d",&n,&l,&v1,&v2);
	for (int i=0;i<n;i++) scanf("%d",&a[i]);
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}

/*
10 100 1 2
25 51 71 126 143 148 167 179 180 199
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007
#define EPS 1e-11

int n,l,v1,v2;
int a[200001];
double f[100001];
vector<double> e;

int main() {
	scanf("%d %d %d %d",&n,&l,&v1,&v2);
	for (int i=0;i<n;i++) scanf("%d",&a[i]);
	for (int i=n;i<2*n;i++) a[i]=a[i-n]+2*l;
	a[2*n]=a[0]+4*l;
	double d=1.0*v2*l/(v1+v2);
	printf("d=%lf\n",d);
	for (int i=0;i<n;i++) {
		e.push_back(a[i]);
		double x=a[i]-d;
		if (x<0) x+=2*l;
		e.push_back(x);
	}
	sort(e.begin(),e.end());
	int j1=0,j2=0;
	for (int i=0;i<e.size();i++) {
		double e1=e[i], e2;
		if (i+1<e.size()) e2=e[i+1]; else e2=e[0]+2*l;
		while (a[j1]<e1+EPS) j1++;
		while (a[j2+1]-e1<d+EPS) j2++;
		f[j2-j1+1]+=e2-e1;
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}

/*
10 100 1 2
25 51 71 126 143 148 167 179 180 199
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
using namespace std;

#define all(c) (c).begin(),(c).end()
#define present(c,x) (find(c.begin(),c.end(),x) != (c).end())
#define pb push_back
#define traverse(v,it) for (typeof(v.begin()) it=v.begin();it!=v.end();it++)
template<class A, class B> A cvt(B x) { stringstream ss; ss<<x; A y; ss>>y; return y; }
typedef long long int64;
typedef pair<int,int> PII;

#define MOD 1000000007

int n,l,v1,v2;
int a[300001];
double f[100001];

int main() {
	scanf("%d %d %d %d",&n,&l,&v1,&v2);
	for (int i=0;i<n;i++) scanf("%d",&a[i]);
	for (int i=n;i<3*n;i++) a[i]=a[i-n]+2*l;
	double d=1.0*v2*l/(v1+v2);
	for (int i=n,j=n;i<2*n;i++) {
		while (a[j+1]-a[i]<d) j++;
		f[j-i+1]+=min((double)a[i]-a[i-1],d-(a[j]-a[i]));
	}
	double s=0;
	for (int i=1;i<=n;i++) {
		f[i]/=(2.0*l);
		s+=f[i];
	}
	printf("%.11lf\n",1.0-s);
	for (int i=1;i<=n;i++) {
		printf("%.11lf\n",f[i]);
	}
    return 0;
}


#include<iostream>
#include<vector>
#include<sstream>
#include<algorithm>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<complex>
#include<set>
#include<map>
#include<queue>
#include<cassert>

using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define rp(i,c) rep(i,(c).size())
#define fr(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pi;
typedef long long ll;

const int inf=1<<28;
const double INF=1e12,EPS=1e-9;

double a[100000], p[100000];

void run()
{
	int n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	rep(i, n) cin >> a[i];
	sort(a, a + n);
	rep(i, n) a[i+n] = a[i] + 2 * l;
	double d = v2 * 1.0 * l / (v1 + v2);
	map<double, int> ps;

	rep(i, n) ps[a[i]]--;
	rep(i, 2*n) if(0 <= a[i] - d && a[i] - d < 2 * l) ps[a[i] - d]++;

	if(!ps.count(0)) ps[0] = 0;
	if(!ps.count(2 * l)) ps[2 * l] = 0;

	int cnt = lower_bound(a, a + 2 * n, d) - a;
	fr(i, ps){
		cnt += i->second;
		map<double, int>::iterator it = i;
		it++;
		if(it == ps.end()) break;
		p[cnt] += (it->first - i->first) / (2 * l);
	}

	rep(i, n + 1) printf("%.20f\n", p[i]);
}

int main()
{
#ifndef ONLINE_JUDGE
	int cs=3;rep(i,cs)
#endif
	run();
}


#include<iostream>
#include<vector>
#include<sstream>
#include<algorithm>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<complex>
#include<set>
#include<map>
#include<queue>
#include<cassert>

using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define rp(i,c) rep(i,(c).size())
#define fr(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pi;
typedef long long ll;

const int inf=1<<28;
const double INF=1e12,EPS=1e-9;

int a[100000];
double p[100000];

void run()
{
	int n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	rep(i, n) cin >> a[i];
	sort(a, a + n);
	rep(i, n) a[i+n] = a[i] + 2 * l;
	double d = v2 * 1.0 * l / (v1 + v2);
	map<double, int> ps;

	rep(i, n) ps[a[i]]--;
	rep(i, 2*n) if(0 <= a[i] - d && a[i] - d < 2 * l) ps[a[i] - d]++;

	if(!ps.count(2 * l)) ps[2 * l] = 0;
	int cnt = lower_bound(a, a + 2 * n, d) - a;
	fr(i, ps){
		cnt += i->second;
		map<double, int>::iterator it = i;
		it++;
		if(it == ps.end()) break;
		p[cnt] += (it->first - i->first) / (2 * l);
	}

	rep(i, n + 1) printf("%.20f\n", p[i]);
}

int main()
{
#ifndef ONLINE_JUDGE
	int cs=3;rep(i,cs)
#endif
	run();
}


#include<iostream>
#include<vector>
#include<sstream>
#include<algorithm>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<complex>
#include<set>
#include<map>
#include<queue>
#include<cassert>

using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define rp(i,c) rep(i,(c).size())
#define fr(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pi;
typedef long long ll;

const int inf=1<<28;
const double INF=1e12,EPS=1e-9;

double a[200000], p[100001];

void run()
{
	int n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	rep(i, n) cin >> a[i];
	sort(a, a + n);
	rep(i, n) a[i+n] = a[i] + 2 * l;
	double d = v2 * 1.0 * l / (v1 + v2);
	map<double, int> ps;

	rep(i, n) ps[a[i]]--;
	rep(i, 2*n) if(0 <= a[i] - d && a[i] - d < 2 * l) ps[a[i] - d]++;

	if(!ps.count(0)) ps[0] = 0;
	if(!ps.count(2 * l)) ps[2 * l] = 0;

	int cnt = lower_bound(a, a + 2 * n, d) - a;
	fr(i, ps){
		cnt += i->second;
		map<double, int>::iterator it = i;
		it++;
		if(it == ps.end()) break;
		p[cnt] += (it->first - i->first) / (2 * l);
	}

	rep(i, n + 1) printf("%.20f\n", p[i]);
}

int main()
{
#ifndef ONLINE_JUDGE
	int cs=3;rep(i,cs)
#endif
	run();
}


#include<iostream>
#include<vector>
#include<sstream>
#include<algorithm>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<complex>
#include<set>
#include<map>
#include<queue>
#include<cassert>

using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define rp(i,c) rep(i,(c).size())
#define fr(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pi;
typedef long long ll;

const int inf=1<<28;
const double INF=1e12,EPS=1e-9;

int a[100000];
double p[100000];

void run()
{
	int n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	rep(i, n) cin >> a[i];
	sort(a, a + n);
	rep(i, n) a[i+n] = a[i] + 2 * l;
	double d = v2 * 1.0 * l / (v1 + v2);
	map<double, int> ps;

	rep(i, n) ps[a[i]]--;
	rep(i, 2*n) if(0 <= a[i] - d && a[i] - d < 2 * l) ps[a[i] - d]++;

	if(!ps.count(0)) ps[0] = 0;
	if(!ps.count(2 * l)) ps[2 * l] = 0;

	int cnt = lower_bound(a, a + 2 * n, d) - a;
	fr(i, ps){
		cnt += i->second;
		map<double, int>::iterator it = i;
		it++;
		if(it == ps.end()) break;
		p[cnt] += (it->first - i->first) / (2 * l);
	}

	rep(i, n + 1) printf("%.20f\n", p[i]);
}

int main()
{
#ifndef ONLINE_JUDGE
	int cs=3;rep(i,cs)
#endif
	run();
}


#include<iostream>
#include<vector>
#include<sstream>
#include<algorithm>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<complex>
#include<set>
#include<map>
#include<queue>
#include<cassert>

using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define rp(i,c) rep(i,(c).size())
#define fr(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pi;
typedef long long ll;

const int inf=1<<28;
const double INF=1e12,EPS=1e-9;

double a[200000], p[100000];

void run()
{
	int n, l, v1, v2;
	cin >> n >> l >> v1 >> v2;
	rep(i, n) cin >> a[i];
	sort(a, a + n);
	rep(i, n) a[i+n] = a[i] + 2 * l;
	double d = v2 * 1.0 * l / (v1 + v2);
	map<double, int> ps;

	rep(i, n) ps[a[i]]--;
	rep(i, 2*n) if(0 <= a[i] - d && a[i] - d < 2 * l) ps[a[i] - d]++;

	if(!ps.count(0)) ps[0] = 0;
	if(!ps.count(2 * l)) ps[2 * l] = 0;

	int cnt = lower_bound(a, a + 2 * n, d) - a;
	fr(i, ps){
		cnt += i->second;
		map<double, int>::iterator it = i;
		it++;
		if(it == ps.end()) break;
		p[cnt] += (it->first - i->first) / (2 * l);
	}

	rep(i, n + 1) printf("%.20f\n", p[i]);
}

int main()
{
#ifndef ONLINE_JUDGE
	int cs=3;rep(i,cs)
#endif
	run();
}


#include <algorithm>
#include <iostream>
#include <string>
#include <cstdio>
#include <vector>
using namespace std;

double p[100005];

struct event {
	double x;
	bool en;
	bool operator<(const event &sec) const {
		return x != sec.x ? x < sec.x : en < sec.en;
	}
} arr[400005];
int q = 0;

int main() {
	int n, le;
	double v1, v2;
	cin >> n >> le >> v1 >> v2;
	double len = le / (v1 + v2) * v2;
	for (int i = 0; i < n; ++i) {
		double x;
		cin >> x;
		arr[q].x = x - len;
		arr[q].en = true;
		++q;
		arr[q].x = x;
		arr[q].en = false;
		++q;

		arr[q].x = 2 * le + x - len;
		arr[q].en = true;
		++q;
		arr[q].x = 2 * le + x;
		arr[q].en = false;
		++q;
	}
	arr[q].x = 0;
	arr[q].en = false;
  ++q;

	arr[q].x = 2 * le;
	arr[q].en = false;
  ++q;
	sort(arr, arr + q);
	double last = 0;
	int cur = 0, o = 1;
	while (arr[cur].x < 0) {
    if (arr[cur].en) {
      ++o;
    } else {
      --o;
    }
		++cur;
	}
	while (o >= 0) {
		p[o] += arr[cur].x - last;
		if (arr[cur].en) {
			++o;
		} else {
			--o;
		}
		last = arr[cur].x;
		++cur;
	}
	for (int i = 0; i <= n; ++i) {
		printf("%.12f\n", p[i] / (2 * le));
	}
	return 0;
}


#include <algorithm>
#include <iostream>
#include <string>
#include <cstdio>
#include <vector>
using namespace std;

const double kEps = 1e-10;

double p[200005];

struct event {
	double x;
	bool en;
	bool operator<(const event &sec) const {
		return x != sec.x ? x < sec.x : en < sec.en;
	}
} arr[500005];
int q = 0;

int main() {
	int n, le;
	double v1, v2;
	cin >> n >> le >> v1 >> v2;
	double len = le / (v1 + v2) * v2;
	for (int i = 0; i < n; ++i) {
		double x;
		cin >> x;
		arr[q].x = x - len;
		arr[q].en = true;
		++q;
		arr[q].x = x;
		arr[q].en = false;
		++q;

		arr[q].x = 2 * le + x - len;
		arr[q].en = true;
		++q;
		arr[q].x = 2 * le + x;
		arr[q].en = false;
		++q;
	}
	arr[q].x = 0;
	arr[q].en = false;
	++q;

	arr[q].x = 2 * le;
	arr[q].en = false;
	++q;
	sort(arr, arr + q);
	double last = 0;
	int cur = 0, o = 1;
	while (arr[cur].x < -kEps) {
		if (arr[cur].en) {
			++o;
		} else {
			--o;
		}
		++cur;
	}
	while (arr[cur].x <= 2 * le + kEps) {
		p[o] += arr[cur].x - last;
		if (arr[cur].en) {
			++o;
		} else {
			--o;
		}
		last = arr[cur].x;
		++cur;
	}
	for (int i = 0; i <= n; ++i) {
		printf("%.12f\n", p[i] / (2 * le));
	}
	return 0;
}


#include <algorithm>
#include <iostream>
#include <string>
#include <cstdio>
#include <vector>
using namespace std;

const double kEps = 1e-10;

double p[200005];

struct event {
	double x;
	bool en;
	bool operator<(const event &sec) const {
		return x != sec.x ? x < sec.x : en < sec.en;
	}
} arr[500005];
int q = 0;

int main() {
	int n, le;
	double v1, v2;
	cin >> n >> le >> v1 >> v2;
	double len = le / (v1 + v2) * v2;
	for (int i = 0; i < n; ++i) {
		double x;
		cin >> x;
		arr[q].x = x - len;
		arr[q].en = true;
		++q;
		arr[q].x = x;
		arr[q].en = false;
		++q;

		arr[q].x = 2 * le + x - len;
		arr[q].en = true;
		++q;
		arr[q].x = 2 * le + x;
		arr[q].en = false;
		++q;
	}
	arr[q].x = 0;
	arr[q].en = false;
  ++q;

	arr[q].x = 2 * le + kEps;
	arr[q].en = false;
  ++q;
	sort(arr, arr + q);
	double last = 0;
	int cur = 0, o = 1;
	while (arr[cur].x < -kEps) {
    if (arr[cur].en) {
      ++o;
    } else {
      --o;
    }
		++cur;
	}
	while (arr[cur].x <= 2 * le) {
		p[o] += arr[cur].x - last;
		if (arr[cur].en) {
			++o;
		} else {
			--o;
		}
		last = arr[cur].x;
		++cur;
	}
	for (int i = 0; i <= n; ++i) {
		printf("%.12f\n", p[i] / (2 * le));
	}
	return 0;
}


#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

using namespace std;

int main()
{
    int64_t n, l, v1, v2;

    cin >> n >> l >> v1 >> v2;
    int d = l * v2;
    l *= v1 + v2;
    l *= 2;

    int64_t* a = new int64_t [2 * n + 1];
    for (int i = 0; i < n; i++){
        cin >> a[i];
        a[i] *= v1 + v2;
        a[i + n] = a[i] + l;
    }
    a[2 * n] = a[n] + l;

    int64_t* v = new int64_t [n + 1];

    int k = 0, i;
    int64_t p = a[0];
    for (i = 0; i <= n; i++) v[i] = 0;
    i = 1;

    while (a[k + 1] < p + d) k++;
    while (p < a[n]){
        if ( (a[i] - p) < (a[i + k] - p - d) ){
            v[k] += (a[i] - p);
            p = a[i++];
            k--;
        }
        else{
            v[k] += (a[i + k] - p - d);
            p += (a[i + k] - p - d);
            k++;
        }
    }

    for (i = 0; i <= n; i++) printf("%.20lf\n", ( (double) v[i]) / l);

    delete [] a;
    delete [] v;

    return 0;
}


#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

using namespace std;

int main()
{
    int64_t n, l, v1, v2;

    cin >> n >> l >> v1 >> v2;
    int64_t d = l * v2;
    l *= v1 + v2;
    l *= 2;

    int64_t* a = new int64_t [2 * n + 1];
    for (int i = 0; i < n; i++){
        cin >> a[i];
        a[i] *= v1 + v2;
        a[i + n] = a[i] + l;
    }
    a[2 * n] = a[n] + l;

    int64_t* v = new int64_t [n + 1];

    int k = 0, i;
    int64_t p = a[0];
    for (i = 0; i <= n; i++) v[i] = 0;
    i = 1;

    while (a[k + 1] < p + d) k++;
    while (p < a[n]){
        if ( (a[i] - p) < (a[i + k] - p - d) ){
            v[k] += (a[i] - p);
            p = a[i++];
            k--;
        }
        else{
            v[k] += (a[i + k] - p - d);
            p += (a[i + k] - p - d);
            k++;
        }
    }

    for (i = 0; i <= n; i++) printf("%.20lf\n", ( (double) v[i]) / l);

    delete [] a;
    delete [] v;

    return 0;
}


#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

using namespace std;

struct unit{
    int num;
    int size;
};

int cmp(const void *a, const void *b){
    return ( (unit*) a)->size - ( (unit*) b)->size;
}

int main()
{
    int64_t n, l, v1, v2;

    cin >> n >> l >> v1 >> v2;
    int d = l * v2;
    l *= v1 + v2;
    l *= 2;

    int* a = new int [2 * n + 1];
    for (int i = 0; i < n; i++){
        cin >> a[i];
        a[i] *= v1 + v2;
        a[i + n] = a[i] + l;
    }
    a[2 * n] = a[n] + l;

    int* v = new int [n + 1];

    int k = 0, p = a[0], i;
    for (i = 0; i <= n; i++) v[i] = 0;
    i = 1;

    while (a[k + 1] < p + d) k++;
    while (p < a[n]){
        if ( (a[i] - p) < (a[i + k] - p - d) ){
            v[k] += (a[i] - p);
            p = a[i++];
            k--;
        }
        else{
            v[k] += (a[i + k] - p - d);
            p += (a[i + k] - p - d);
            k++;
        }
    }

    for (i = 0; i <= n; i++) printf("%.20lf\n", ( (double) v[i]) / l);

    delete [] a;
    delete [] v;

    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>

using namespace std;
using namespace __gnu_cxx;

#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)

#define FE(i,t) for (__typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (__typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)

#define two(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()

#define pb push_back
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;

template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n==0)?0:1+count_bit(n&(n-1));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:ctz(n>>1)+1);}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}

const int maxn=111111;
double px[maxn];
int v1, v2;
int a[maxn];
int n, l;

struct event{
    double t;
    int type;
    event(double t, int type):t(t), type(type){}
    bool operator<(const event &e)const{ return t<e.t; }
};

int main(){
    cin>>n>>l>>v1>>v2;
    REP(i,n) scanf(" %d", a+i);
    double tot=1.*l/(v1+v2);
    double d=tot*v2;
    REPV(i,n) a[i]-=a[0];

    vector<event> el;
    el.pb(event(2*l,2));
    int last=1;
    int have=0;
    for (; a[last]<d && last<n; ++last){
        el.pb(event(a[last],1));
        ++have;
        el.pb(event(2*l+a[last]-d,1));
    }

    for (int i=last; i<n; ++i){ el.pb(event(a[i]-d,0)); el.pb(event(a[i],1));}

    el.pb(event(2*l+a[0]-d,0)); el.pb(event(2*l+a[0],1));
    sort(ALL(el));
    double ot=0.;
    REP(i,el.size()){
        event &e=el[i];
        if (ot<e.t) px[have]+=(e.t-ot)/2/l;
        if (e.type==2) break;
        if (e.type==0) ++have;
        else --have;
        ot=e.t;
    }

    REP(i,n+1) printf("%.11lf\n", px[i]);
    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>

using namespace std;
using namespace __gnu_cxx;

#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)

#define FE(i,t) for (__typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (__typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)

#define two(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()

#define pb push_back
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;

template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n==0)?0:1+count_bit(n&(n-1));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:ctz(n>>1)+1);}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}

const int maxn=111111;
double px[maxn];
int v1, v2;
int a[maxn];
int n, l;

struct event{
    double t;
    int type;
    event(double t, int type):t(t), type(type){}
    bool operator<(const event &e)const{ return t<e.t; }
};

int main(){
    cin>>n>>l>>v1>>v2;
    REP(i,n) scanf(" %d", a+i);
    double tot=1.*l/(v1+v2);
    double d=tot*v2;
    REPV(i,n) a[i]-=a[0];

    vector<event> el;
    el.pb(event(2*l,2));
    int last=1;
    int have=0;
    for (; a[last]<d && last<n; ++last){
        el.pb(event(a[last],1));
        ++have;
        el.pb(event(2.*l+a[last]-d,0));
    }

    for (int i=last; i<n; ++i){ el.pb(event(a[i]-d,0)); el.pb(event(a[i],1));}

    el.pb(event(2*l-d,0));
    sort(ALL(el));
    double ot=0.;
    REP(i,el.size()){
        event &e=el[i];
        if (ot<e.t) px[have]+=(e.t-ot)/2/l;
        if (e.type==2) break;
        if (e.type==0) ++have;
        else --have;
        ot=e.t;
    }

    REP(i,n+1) printf("%.11lf\n", px[i]);
    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>

using namespace std;
using namespace __gnu_cxx;

#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)

#define FE(i,t) for (__typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (__typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)

#define two(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()

#define pb push_back
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;

template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n==0)?0:1+count_bit(n&(n-1));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:ctz(n>>1)+1);}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}

const int maxn=111111;
double px[maxn];
int v1, v2;
int a[maxn];
int n, l;

struct event{
    double t;
    int type;
    event(double t, int type):t(t), type(type){}
    bool operator<(const event &e)const{ return t<e.t; }
};

int main(){
    cin>>n>>l>>v1>>v2;
    REP(i,n) scanf(" %d", a+i);
    double tot=1.*l/(v1+v2);
    double d=tot*v2;
    REPV(i,n) a[i]-=a[0];

    vector<event> el;
    el.pb(event(2*l,2));
    int last=1;
    int have=0;
    for (; a[last]<d && last<n; ++last){
        el.pb(event(a[last],1));
        ++have;
        el.pb(event(2.*l+a[last]-d,1));
    }

    for (int i=last; i<n; ++i){ el.pb(event(a[i]-d,0)); el.pb(event(a[i],1));}

    el.pb(event(2*l-d,0));
    sort(ALL(el));
    double ot=0.;
    REP(i,el.size()){
        event &e=el[i];
        if (ot<e.t) px[have]+=(e.t-ot)/2/l;
        if (e.type==2) break;
        if (e.type==0) ++have;
        else --have;
        ot=e.t;
    }

    REP(i,n+1) printf("%.11lf\n", px[i]);
    return 0;
}


#include <cstdio>
#include <cstring>
#include <cmath>

#include <iostream>
#include <algorithm>

using namespace std;
typedef long long LL;
typedef double db;

const db eps = 1e-9;
const int Mod = 1000000007;
const int MaxN = 100010;

struct event{
    db x;
    char f;
    event(){}
    event(db x,char f):x(x),f(f){}
    bool operator <(const event &e)const{
        if (fabs(x - e.x) < eps) return f < e.f;
        return x < e.x;
    }
};

event evt[MaxN * 2];
db P[MaxN];

int main(){
    int n,l,v1,v2;
    while (scanf("%d%d%d%d",&n,&l,&v1,&v2) != EOF){
        memset(P,0,sizeof(P[0]) * (n + 1));
        db dis = l * v2 * 1.0 / (v1 + v2);
        db l2 = l * 2.0;
        int en = 0;
        int c = 0;
        for (int i = 0;i < n;i++){
            int a;
            scanf("%d",&a);
            db s = -a;
            db t = -a + dis;
            while (s < -eps) s += l2;
            while (t < -eps) t += l2;
            while (t > l2 - eps) t -= l2;
            if (s > t) ++c;
            evt[en++] = event(s,1);
            evt[en++] = event(t,-1);
        }
        evt[en++] = event(0.0,0);
        evt[en++] = event(l2,0);
        sort(evt,evt + en);
        //printf("dis = %f\n",dis);for (int i = 0;i < en;i++)printf("%f(%d) ",evt[i].x,evt[i].f);puts("");
        int ce = 0;
        db px = 0.0;
        while (ce < en){
            db cx = evt[ce].x;
            //printf("(%f,%f] %d\n",px,cx,c);
            P[c] += cx - px;
            while (ce < en && fabs(evt[ce].x - cx) < eps)
                c += evt[ce++].f;
            px = cx;
        }
        for (int i = 0;i <= n;i++)
            printf("%.12f\n",P[i] / l2);
    }
    return 0;
}
}


#include <cstdio>
#include <cstring>
#include <cmath>

#include <iostream>
#include <algorithm>

using namespace std;
typedef long long LL;
typedef double db;

const db eps = 1e-9;
const int Mod = 1000000007;
const int MaxN = 100010;

struct event{
    db x;
    char f;
    event(){}
    event(db x,char f):x(x),f(f){}
    bool operator <(const event &e)const{
        if (fabs(x - e.x) < eps) return f < e.f;
        return x < e.x;
    }
};

event evt[MaxN * 2];
db P[MaxN];

int main(){
    int n,l,v1,v2;
    while (scanf("%d%d%d%d",&n,&l,&v1,&v2) != EOF){
        memset(P,0,sizeof(P[0]) * (n + 1));
        db dis = l * v2 * 1.0 / (v1 + v2);
        db l2 = l * 2.0;
        int en = 0;
        int c = 0;
        for (int i = 0;i < n;i++){
            int a;
            scanf("%d",&a);
            db s = -a;
            db t = -a + dis;
            while (s < -eps) s += l2;
            while (t < -eps) t += l2;
            while (t > l2 - eps) t -= l2;
            if (s > t) ++c;
            evt[en++] = event(s,1);
            evt[en++] = event(t,-1);
        }
        evt[en++] = event(0.0,0);
        evt[en++] = event(l2,0);
        sort(evt,evt + en);
        //printf("dis = %f\n",dis);for (int i = 0;i < en;i++)printf("%f(%d) ",evt[i].x,evt[i].f);puts("");
        int ce = 0;
        db px = 0.0;
        while (ce < en){
            db cx = evt[ce].x;
            //printf("(%f,%f] %d\n",px,cx,c);
            P[c] += cx - px;
            while (ce < en && evt[ce].x < cx + eps)
                c += evt[ce++].f;
            px = cx;
        }
        for (int i = 0;i <= n;i++)
            printf("%.12f\n",P[i] / l2);
    }
    return 0;
}


#include <cstdio>
#include <cstring>
#include <cmath>

#include <iostream>
#include <algorithm>

using namespace std;
typedef long long LL;
typedef double db;

const db eps = 1e-9;
const int Mod = 1000000007;
const int MaxN = 100010;

struct event{
    db x;
    char f;
    event(){}
    event(db x,char f):x(x),f(f){}
    bool operator <(const event &e)const{
        if (fabs(x - e.x) < eps) return f < e.f;
        return x < e.x;
    }
};

event evt[MaxN * 2];
db P[MaxN];

int main(){
    int n,l,v1,v2;
    while (scanf("%d%d%d%d",&n,&l,&v1,&v2) != EOF){
        memset(P,0,sizeof(P[0]) * (n + 1));
        db dis = l * v2 * 1.0 / (v1 + v2);
        db l2 = l * 2.0;
        int en = 0;
        int c = 0;
        for (int i = 0;i < n;i++){
            int a;
            scanf("%d",&a);
            db s = -a;
            db t = -a + dis;
            while (s < -eps) s += l2;
            while (t < -eps) t += l2;
            while (t > l2 - eps) t -= l2;
            if (s > t) ++c;
            evt[en++] = event(s,1);
            evt[en++] = event(t,-1);
        }
        evt[en++] = event(0.0,0);
        evt[en++] = event(l2,0);
        sort(evt,evt + en);
        //printf("dis = %f\n",dis);for (int i = 0;i < en;i++)printf("%f(%d) ",evt[i].x,evt[i].f);puts("");
        int ce = 0;
        db px = 0.0;
        while (ce < en){
            db cx = evt[ce].x;
            //printf("(%f,%f] %d\n",px,cx,c);
            P[c] += cx - px;
            while (ce < en && fabs(evt[ce].x - cx) < eps)
                c += evt[ce++].f;
            px = cx;
        }
        for (int i = 0;i <= n;i++)
            printf("%.12f\n",P[i] / l2);
    }
    return 0;
}


#include <cstdio>
#include <cstring>
#include <cmath>

#include <iostream>
#include <algorithm>

using namespace std;
typedef long long LL;
typedef double db;

const db eps = 1e-9;
const int Mod = 1000000007;
const int MaxN = 100010;

struct event{
    db x;
    char f;
    event(){}
    event(db x,char f):x(x),f(f){}
    bool operator <(const event &e)const{
        if (fabs(x - e.x) < eps) return f < e.f;
        return x < e.x;
    }
};

event evt[MaxN * 2];
db P[MaxN];

int main(){
    int n,l,v1,v2;
    while (scanf("%d%d%d%d",&n,&l,&v1,&v2) != EOF){
        memset(P,0,sizeof(P[0]) * (n + 1));
        db dis = l * v1 * 1.0 / (v1 + v2);
        int en = 0;
        for (int i = 0;i < n;i++){
            int a;
            scanf("%d",&a);
            evt[en++] = event(a - dis,1);
            evt[en++] = event(a + dis,-1);
        }
        evt[en++] = event(l * 2.0,0);
        sort(evt,evt + en);
        //printf("dis = %f\n",dis);for (int i = 0;i < en;i++)printf("%f(%d) ",evt[i].x,evt[i].f);puts("");
        int c = 0;
        int ce = 0;
        db px = 0.0;
        while (ce < en && evt[ce].x < px - eps)
            c += evt[ce++].f;
        while (ce < en){
            db cx = evt[ce].x;
            //printf("(%f,%f] %d\n",px,cx,c);
            P[c] += cx - px;
            while (ce < en && fabs(evt[ce].x - cx) < eps)
                c += evt[ce++].f;
            px = cx;
        }
        for (int i = 0;i <= n;i++)
            printf("%.12f\n",P[i] / l / 2.0);
    }
    return 0;
}


#include <cstdio>
#include <cstring>
#include <cmath>

#include <iostream>
#include <algorithm>

using namespace std;
typedef long long LL;
typedef double db;

const db eps = 1e-9;
const int Mod = 1000000007;
const int MaxN = 100010;

struct event{
    db x;
    char f;
    event(){}
    event(db x,char f):x(x),f(f){}
    bool operator <(const event &e)const{
        if (fabs(x - e.x) < eps) return f < e.f;
        return x < e.x;
    }
};

event evt[MaxN * 2];
db P[MaxN];

int main(){
    int n,l,v1,v2;
    while (scanf("%d%d%d%d",&n,&l,&v1,&v2) != EOF){
        memset(P,0,sizeof(P[0]) * (n + 1));
        db dis = l * 1.0 * v2 / (v1 + v2);
        db l2 = l * 2.0;
        int en = 0;
        int c = 0;
        for (int i = 0;i < n;i++){
            int a;
            scanf("%d",&a);
            db s = -a;
            db t = -a + dis;
            while (s < -eps) s += l2;
            while (t < -eps) t += l2;
            while (t > l2 - eps) t -= l2;
            if (s > t) ++c;
            evt[en++] = event(s,1);
            evt[en++] = event(t,-1);
        }
        evt[en++] = event(0.0,0);
        evt[en++] = event(l2,0);
        sort(evt,evt + en);
        //printf("dis = %f\n",dis);for (int i = 0;i < en;i++)printf("%f(%d) ",evt[i].x,evt[i].f);puts("");
        int ce = 0;
        db px = 0.0;
        while (ce < en){
            db cx = evt[ce].x;
            //printf("(%f,%f] %d\n",px,cx,c);
            P[c] += cx - px;
            while (ce < en && fabs(evt[ce].x - cx) < eps)
                c += evt[ce++].f;
            px = cx;
        }
        for (int i = 0;i <= n;i++)
            printf("%.12f\n",P[i] / l2);
    }
    return 0;
}


#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#define MAXN 100050

using namespace std;

typedef pair<int,int> PII;

const int epow=14;
long double eps;

inline long double abs(long double x) { x>=0.0? x:-x; }
inline bool iszero(long double x) { return abs(x)<eps; }
inline bool equal(long double a,long double b) { return iszero(a-b); }

class Event {
   public:
      long double t;
      int a;
      Event(long double _t,int _a):t(_t),a(_a) {}
      const bool operator<(const Event &b) const {
         if(!equal(t,b.t)) return t<b.t;
         return a<b.a;
      }
};

int n,l,v1,v2;
int pos[MAXN];
vector<Event> event;
long double sol[MAXN];

inline void solve() {
   int c=0;
   long double d=(long double)v2/(v1+v2)*l;
   for(int i=0;i<n;i++) {
      long double t1=pos[i]-d;
      long double t2=pos[i];
      if(t1<0.0-eps) t1+=2*l;
      event.push_back(Event(t1,1));
      event.push_back(Event(t2,-1));
      if(t1>t2) c++;
   }
   sort(event.begin(),event.end());
   long double pt=0.0;
   for(int i=0;i<=n;i++)
      sol[i]=0.0;
   for(int i=0;i<event.size();i++) {
      Event e=event[i];
      long double t=e.t;
      int a=e.a;
      //printf("<%d>\n",c);
      sol[c]+=t-pt;
      pt=t;
      c+=a;
   }
   sol[c]+=2*l-pt;
   for(int i=0;i<=n;i++) {
      sol[i]/=2*l;
      cout << setprecision(15) << sol[i] << endl;
   }
}

int main(void)
{
   eps=(long double)1.0;
   for(int i=0;i<epow;i++)
      eps/=10;
   scanf("%d %d %d %d",&n,&l,&v1,&v2);
   for(int i=0;i<n;i++)
      scanf("%d",pos+i);
   solve();
   return 0;
}


#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#define MAXN 100050

using namespace std;

typedef pair<int,int> PII;

const int epow=14;
long double eps;

inline long double abs(long double x) { return x>=0.0? x:-x; }
inline bool iszero(long double x) { return abs(x)<eps; }
inline bool equal(long double a,long double b) { return iszero(a-b); }

class Event {
   public:
      long double t;
      int a;
      Event(long double _t,int _a):t(_t),a(_a) {}
      const bool operator<(const Event &b) const {
         if(!equal(t,b.t)) return t<b.t;
         return a>b.a;
      }
};

int n,l,v1,v2;
int pos[MAXN];
vector<Event> event;
long double sol[MAXN*2];

inline void solve() {
   int c=0;
   long double d=(long double)v2/(v1+v2)*l;
   for(int i=0;i<n;i++) {
      long double t1=pos[i]-d;
      long double t2=pos[i];
      if(t1<0.0-eps) t1+=2*l;
      event.push_back(Event(t1,1));
      event.push_back(Event(t2,-1));
      if(t1>t2) c++;
   }
   sort(event.begin(),event.end());
   long double pt=0.0;
   for(int i=0;i<=n;i++)
      sol[i]=0.0;
   for(int i=0;i<event.size();i++) {
      Event e=event[i];
      long double t=e.t;
      int a=e.a;
      //printf("<%d>\n",c);
      if(!iszero(t-pt)) sol[c]+=t-pt;
      pt=t;
      c+=a;
   }
   sol[c]+=2*l-pt;
   for(int i=0;i<=n;i++) {
      sol[i]/=2*l;
      cout << setprecision(15) << sol[i] << endl;
   }
}

int main(void)
{
   eps=(long double)1.0;
   for(int i=0;i<epow;i++)
      eps/=10;
   scanf("%d %d %d %d",&n,&l,&v1,&v2);
   for(int i=0;i<n;i++)
      scanf("%d",pos+i);
   solve();
   return 0;
}


#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#define MAXN 100050

using namespace std;

typedef pair<int,int> PII;

const int epow=14;
long double eps;

inline long double abs(long double x) { x>=0.0? x:-x; }
inline bool iszero(long double x) { return abs(x)<eps; }
inline bool equal(long double a,long double b) { return iszero(a-b); }

class Event {
   public:
      long double t;
      int a;
      Event(long double _t,int _a):t(_t),a(_a) {}
      const bool operator<(const Event &b) const {
         if(!equal(t,b.t)) return t<b.t;
         return a>b.a;
      }
};

int n,l,v1,v2;
int pos[MAXN];
vector<Event> event;
long double sol[MAXN*2];

inline void solve() {
   int c=0;
   long double d=(long double)v2/(v1+v2)*l;
   for(int i=0;i<n;i++) {
      long double t1=pos[i]-d;
      long double t2=pos[i];
      if(t1<0.0-eps) t1+=2*l;
      event.push_back(Event(t1,1));
      event.push_back(Event(t2,-1));
      if(t1>t2) c++;
   }
   sort(event.begin(),event.end());
   long double pt=0.0;
   for(int i=0;i<=n;i++)
      sol[i]=0.0;
   for(int i=0;i<event.size();i++) {
      Event e=event[i];
      long double t=e.t;
      int a=e.a;
      //printf("<%d>\n",c);
      if(!iszero(t-pt)) sol[c]+=t-pt;
      pt=t;
      c+=a;
   }
   sol[c]+=2*l-pt;
   for(int i=0;i<=n;i++) {
      sol[i]/=2*l;
      cout << setprecision(15) << sol[i] << endl;
   }
}

int main(void)
{
   eps=(long double)1.0;
   for(int i=0;i<epow;i++)
      eps/=10;
   scanf("%d %d %d %d",&n,&l,&v1,&v2);
   for(int i=0;i<n;i++)
      scanf("%d",pos+i);
   solve();
   return 0;
}


#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const long double EPS = 1e-9;
static const long double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n;
long double l, v1, v2;
long double ans[100010];
int pos[100010];

void calc() {
  long double d = l * v2 / (v1 + v2);
  vector<pair<long double, int> > poss;
  for (int i = 0; i < n; i++) {
    long double inX = 2 * l - pos[i];
    long double outX = inX + d;
    REP(iter, 3) {
      poss.push_back(make_pair(inX + iter * 2 * l, (i + 1)));
      poss.push_back(make_pair(outX + iter * 2 * l, -(i + 1)));
    }
  }
  sort(poss.begin(), poss.end());
  vector<bool> used(n, false);
  int lsum = 0;
  long double px = 0.0;
  REP(i, poss.size()) {
    long double x = poss[i].first;
    int index = abs(poss[i].second) - 1;
    bool start = poss[i].second > 0 ? true : false;
    if (2 * l <= x) {
      ans[lsum] += (min(x, 4 * l) - max(px, 2 * l)) / (2 * l);
    }
    px = x;
    if (x >= 4 * l) { break; }
    if (used[index] && !start) {
      used[index] = false;
      lsum--;
    } else if (!used[index] && start) {
      used[index] = true;
      lsum++;
    }
  }
}

int main() {
  while (scanf("%d %Lf %Lf %Lf", &n, &l, &v1, &v2) > 0) {
    MEMSET(ans, 0);
    REP(i, n) {
      scanf("%d", &pos[i]);
    }
    calc();
    REP(i, n + 1) {
      printf("%.14Lf\n", ans[i]);
    }
  }
}


#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const long double EPS = 1e-9;
static const long double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n;
long double l, v1, v2;
long double ans[100010];
int pos[100010];

void calc() {
  long double d = l * v2 / (v1 + v2);
  vector<pair<long double, int> > poss;
  for (int i = 0; i < n; i++) {
    long double inX = 2 * l - pos[i];
    long double outX = inX + d;
    REP(iter, 3) {
      poss.push_back(make_pair(inX + iter * 2 * l, (i + 1)));
      poss.push_back(make_pair(outX + iter * 2 * l, -(i + 1)));
    }
  }
  sort(poss.begin(), poss.end());
  vector<bool> used(n, false);
  int lsum = 0;
  long double px = 0.0;
  REP(i, poss.size()) {
    long double x = poss[i].first;
    int index = abs(poss[i].second) - 1;
    bool start = poss[i].second > 0 ? true : false;
    if (2 * l <= x) {
      ans[lsum] += (min(x, 4 * l) - max(px, 2 * l)) / (2 * l);
    }
    px = x;
    if (x >= 4 * l) { break; }
    if (used[index] && !start) {
      used[index] = false;
      lsum--;
     else if (!used[index] && start) {
      used[index] = true;
      lsum++;
    }
  }
}

int main() {
  while (scanf("%d %Lf %Lf %Lf", &n, &l, &v1, &v2) > 0) {
    MEMSET(ans, 0);
    REP(i, n) {
      scanf("%d", &pos[i]);
    }
    calc();
    REP(i, n + 1) {
      printf("%.14Lf\n", ans[i]);
    }
  }
}


#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

int n;
double l, v1, v2;
double ans[100010];
int pos[100010];

void calc() {
  double d = l * v2 / (v1 + v2);
  vector<pair<double, int> > poss;
  for (int i = 0; i < n; i++) {
    double inX = 2 * l - pos[i];
    double outX = inX + d;
    REP(iter, 3) {
      poss.push_back(make_pair(inX + iter * 2 * l, (i + 1)));
      poss.push_back(make_pair(outX + iter * 2 * l, -(i + 1)));
    }
  }
  sort(poss.begin(), poss.end());
  vector<bool> used(n, false);
  int lsum = 0;
  double px = 0.0;
  REP(i, poss.size()) {
    double x = poss[i].first;
    int index = abs(poss[i].second) - 1;
    bool start = poss[i].second > 0 ? true : false;
    if (2 * l <= x) {
      ans[lsum] += (min(x, 4 * l) - max(px, 2 * l)) / (2 * l);
    }
    px = x;
    if (x >= 4 * l) { break; }
    if (used[index] && !start) {
      used[index] = false;
      lsum--;
    } else if (!used[index] && start) {
      used[index] = true;
      lsum++;
    }
  }
}

int main() {
  while (scanf("%d %lf %lf %lf", &n, &l, &v1, &v2) > 0) {
    MEMSET(ans, 0);
    REP(i, n) {
      scanf("%d", &pos[i]);
    }
    calc();
    REP(i, n + 1) {
      printf("%.14f\n", ans[i]);
    }
  }
}


// #include <cstring>
// #include <cstdio>
// #include <iostream>
// #include <algorithm>
// #include <vector>
// #include <cmath>
// #include <queue>
// #include <string>
// using namespace std;
//
// struct Node {
// 	int W , V , ID;
// 	bool operator < (const Node &cmp) const {
// 		if (W == cmp.W) return V < cmp.V;
// 		return W < cmp.W;
// 	}
// }hh[111111];
// int ans[111111];
// int n , k , h;
// bool yes(double mid) {
// 	int i = 0 , j = 0;
// 	int H = h;
// 	while (i < n && j < k) {
// 		if (hh[i].V * mid >= H) {
// 			ans[j] = hh[i].ID;
// 			i ++;
// 			j ++;
// 			H += h;
// 		} else i ++;
// 	}
// 	if (j == k) return true;
// 	return false;
// }
// int main() {
// 	scanf("%d%d%d",&n,&k,&h);
// 	for (int i = 0 ; i < n ; i ++) {
// 		scanf("%d",&hh[i].W);
// 		hh[i].ID = i + 1;
// 	}
// 	for (int i = 0 ; i < n ; i ++) {
// 		scanf("%d",&hh[i].V);
// 	}
// 	sort(hh, hh + n);
// 	double lo = 0;
// 	double hi = 1e10;
// 	int t = 100;
// 	while (t --) {
// 		double mid = (lo + hi) / 2;
// 		if (yes(mid)) hi = mid;
// 		else lo = mid;
// 	}
// //	printf("%lf\n",lo);
// 	for (int i = 0 ; i < k ; i ++) {
// 		printf("%d%c",ans[i],(i == k - 1)?'\n':' ');
// 	}
// 	return 0;
// }


#include <vector>
#include <set>
#include <map>
#include <cstdio>
#include <string>
#include <cmath>
#include <algorithm>
#include <iostream>
using namespace std;

long long a[211111];
double sum[111111];
int main() {
	int n , v1 , v2;
	long long len;
	int i , j;
	cin >> n >> len >> v1 >> v2;
	double t = len * 1.0 / (v1 + v2);
	double L = t * v2;
	for (i = 0 ; i < n ; i ++) {
		scanf("%d",&a[i]);
		a[i+n] = a[i] + 2 * len;
	}
	a[2*n] = a[0] + 4 * len;
	for (i = 0 ; i <= n ; i ++) sum[i] = 0;
	double l = a[0], r = a[0] + L;
	double cnt = 0;
	i = 0, j = 0;
	int N = 2 * n;
	while (j < N) {
		if (r < a[j]) {
			j --;
			break;
		}
		j ++;
	}
	while (i < n) {
		double ll = a[i+1] - l;
		double rr = a[j+1] - r;
		if (ll < rr) {
			sum[j - i] += ll;
			l += ll;
			r += ll;
			i ++;
		} else {
			sum[j - i] += rr;
			l += rr;
			r += rr;
			j ++;
		}
	}
	double tot = len * 2;
	for (i = 0 ; i <= n ; i ++) {
		printf("%.10lf\n",sum[i]/tot);
	}
	return 0;
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cassert>
using namespace std;
typedef long long ll;

#define REP(i,n) for (int i=0; i<(int)(n); ++i)
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define FOREQ(i,k,n) for (int i=(k); i<=(int)(n); ++i)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define SZ(v) (int)((v).size())
#define MEMSET(v,h) memset((v),(h),sizeof(v))

struct Event {
  double t;
  int updown;
  bool operator<(const Event &rhs) const {
    return t > rhs.t; // reversed
  }
};

int N;
double res[102000];
double pos[102000];

void outp() {
  REP(i, N+1) printf("%.13f\n", res[i]);
}

int main() {
  double L, v1, v2;
  while (scanf("%d%lf%lf%lf", &N, &L, &v1, &v2) != EOF) {
    REP(i, N) scanf("%lf", pos+i);
    MEMSET(res, 0);

    double c_len = v2 * L / (v1 + v2);
    if (c_len >= 2*L) {
      // crucial case
      res[N] = 1.0;
      outp();
      continue;
    }

    // otherwise : sweeeeeep

    // darui
    REP(i, N) pos[i] += 1.0 / acos(-1.0);

    priority_queue<Event> event;
    REP(i, N) {
      event.push( (Event){pos[i], -1} );
      event.push( (Event){fmod(pos[i] - c_len + 2*L, 2*L), +1} );
    }
    event.push( (Event){2*L, 0}); // dummy event

    double lo = 0;
    int curr_choco = 0;
    REP(i, N) if (pos[i] <= c_len) curr_choco++;

    while (!event.empty()) {
      Event e = event.top(); event.pop();
      double next = e.t;
      res[curr_choco] += next - lo;

      // cout<<"!"<<e.t<<" "<<e.updown<<"  "<<curr_choco<<endl;

      lo = next;
      curr_choco += e.updown;
    }

    REP(i, N+1) res[i] /= 2*L;
    outp();
  }
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cassert>
using namespace std;
typedef long long ll;

#define REP(i,n) for (int i=0; i<(int)(n); ++i)
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define FOREQ(i,k,n) for (int i=(k); i<=(int)(n); ++i)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define SZ(v) (int)((v).size())
#define MEMSET(v,h) memset((v),(h),sizeof(v))

struct Event {
  double t;
  int updown;
  bool operator<(const Event &rhs) const {
    return t > rhs.t; // reversed
  }
};

int N;
double res[102000];
double pos[102000];

void outp() {
  REP(i, N+1) printf("%.13f\n", res[i]);
}

int main() {
  double L, v1, v2;
  while (scanf("%d%lf%lf%lf", &N, &L, &v1, &v2) != EOF) {
    REP(i, N) scanf("%lf", pos+i);
    MEMSET(res, 0);

    double c_len = v2 * L / (v1 + v2);
    if (c_len >= 2*L) {
      // crucial case
      res[N] = 1.0;
      outp();
      continue;
    }

    // otherwise : sweeeeeep

    // darui
    REP(i, N) pos[i] += 0.5;

    priority_queue<Event> event;
    REP(i, N) {
      event.push( (Event){pos[i], -1} );
      event.push( (Event){fmod(pos[i] - c_len + 2*L, 2*L), +1} );
    }
    event.push( (Event){2*L, 0}); // dummy event

    double lo = 0;
    int curr_choco = 0;
    REP(i, N) if (pos[i] <= c_len) curr_choco++;

    while (!event.empty()) {
      Event e = event.top(); event.pop();
      double next = e.t;
      res[curr_choco] += next - lo;

     // cout<<"!"<<e.t<<" "<<e.updown<<"  "<<curr_choco<<endl;

      lo = next;
      curr_choco += e.updown;
    }

    REP(i, N+1) res[i] /= 2*L;
    outp();
  }
}


#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cassert>
using namespace std;
typedef long long ll;

#define REP(i,n) for (int i=0; i<(int)(n); ++i)
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define FOREQ(i,k,n) for (int i=(k); i<=(int)(n); ++i)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define SZ(v) (int)((v).size())
#define MEMSET(v,h) memset((v),(h),sizeof(v))

struct Event {
  double t;
  int updown;
  bool operator<(const Event &rhs) const {
    return t > rhs.t; // reversed
  }
};

int N;
double res[102000];
double pos[102000];

void outp() {
  REP(i, N+1) printf("%.13f\n", res[i]);
}

int main() {
  double L, v1, v2;
  while (scanf("%d%lf%lf%lf", &N, &L, &v1, &v2) != EOF) {
    REP(i, N) scanf("%lf", pos+i);
    MEMSET(res, 0);

    double c_len = v2 * L / (v1 + v2);
    if (c_len >= 2*L) {
      // crucial case
      res[N] = 1.0;
      outp();
      continue;
    }

    // otherwise : sweeeeeep

    // darui
    REP(i, N) pos[i] -= 0.5;

    priority_queue<Event> event;
    REP(i, N) {
      event.push( (Event){pos[i], -1} );
      event.push( (Event){fmod(pos[i] - c_len + 2*L, 2*L), +1} );
    }
    event.push( (Event){2*L, 0}); // dummy event

    double lo = 0;
    int curr_choco = 0;
    REP(i, N) if (pos[i] <= c_len) curr_choco++;

    while (!event.empty()) {
      Event e = event.top(); event.pop();
      double next = e.t;
      res[curr_choco] += next - lo;

     // cout<<"!"<<e.t<<" "<<e.updown<<"  "<<curr_choco<<endl;

      lo = next;
      curr_choco += e.updown;
    }

    REP(i, N+1) res[i] /= 2*L;
    outp();
  }
}


#include <string>
#include <vector>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>

using namespace std;

int m, n, l, v1, v2;
double a[200002];
double b[200002];
double len[100001];
double d;
double eps = 1e-9;

int findmin(double);
int findmax(double);

int main() {
  cin >> n >> l >> v1 >> v2;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    a[n + i] = 2 * l + a[i];
  }
  n = n * 2;
  d = (double)v2 / double(v1 + v2) * double(l);
  m = 0;
  for (int i = 0; i < n / 2; i ++) {
    b[m ++] = a[i];
    b[m ++] = a[i] - d;
    if (b[m - 1] < 0) b[m - 1] += 2l;
  }
  sort(b, b + m);
  if (b[m - 1] < 2 * l - eps) b[m ++] = 2 * l;
  if (b[0] > eps) b[m ++] = 0;
  sort(b, b + m);
  //  for (int i = 0; i < m; i ++) cout << b[i] << endl;
  for (int i = 0; i < m - 1; i ++) {
    double mid = (b[i] + b[i + 1]) / 2;
    int s = findmin(mid);
    int t = findmax(mid + d);
    len[t - s + 1] += (b[i + 1] - b[i]);
  }
  for (int i = 0; i <= n / 2; i ++)
    fprintf(stdout, "%.9lf\n", len[i] / (2 * l));
  return 0;
}

int findmin(double x) {
  int lo = 0;
  int hi = n - 1;
  int res;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (x < a[mid]) {
      res = mid;
      hi = mid - 1;
    }
    else lo = mid + 1;
  }
  return res;
}

int findmax(double x) {
  int lo = 0;
  int hi = n - 1;
  int res;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (a[mid] < x) {
      res = mid;
      lo = mid + 1;
    }
    else hi = mid - 1;
  }
  return res;
}


#include <string>
#include <vector>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>

using namespace std;

int m, n, l, v1, v2;
double a[200002];
double b[200002];
double len[100001];
double d;
double eps = 1e-9;

int findmin(double);
int findmax(double);

int main() {
  cin >> n >> l >> v1 >> v2;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    a[n + i] = 2 * l + a[i];
  }
  n = n * 2;
  d = (double)v2 / double(v1 + v2) * double(l);
  m = 0;
  for (int i = 0; i < n / 2; i ++) {
    b[m ++] = a[i];
    b[m ++] = a[i] - d;
    if (b[m - 1] < 0) b[m - 1] += 2l;
  }
  sort(b, b + m);
  if (b[m - 1] < 2 * l - eps) b[m ++] = 2 * l;
  if (b[0] > eps) b[m ++] = 0;
  sort(b, b + m);
  //for (int i = 0; i < m; i ++) cout << b[i] << endl;
  for (int i = 0; i < m - 1; i ++) {
    double mid = (b[i] + b[i + 1]) / 2;
    int s = findmin(mid);
    int t = findmax(mid + d);
    //    cout << mid << " " << s << " " << t << endl;
    if (s >= 0 && t >= s)
      len[t - s + 1] += (b[i + 1] - b[i]);
    else len[0] += (b[i + 1] - b[i]);
  }
  for (int i = 0; i <= n / 2; i ++)
    fprintf(stdout, "%.9lf\n", len[i] / (2 * l));
  return 0;
}

int findmin(double x) {
  int lo = 0;
  int hi = n - 1;
  int res = -1;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (x < a[mid]) {
      res = mid;
      hi = mid - 1;
    }
    else lo = mid + 1;
  }
  return res;
}

int findmax(double x) {
  int lo = 0;
  int hi = n - 1;
  int res = -1;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (a[mid] < x) {
      res = mid;
      lo = mid + 1;
    }
    else hi = mid - 1;
  }
  return res;
}


#include <string>
#include <vector>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>

using namespace std;

int m, n, l, v1, v2;
double a[200002];
double b[200002];
double len[100001];
double d;
double eps = 1e-9;

int findmin(double);
int findmax(double);

int main() {
  cin >> n >> l >> v1 >> v2;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    a[n + i] = 2 * l + a[i];
  }
  n = n * 2;
  d = (double)v2 / double(v1 + v2) * double(l);
  m = 0;
  for (int i = 0; i < n / 2; i ++) {
    b[m ++] = a[i];
    b[m ++] = a[i] - d;
    if (b[m - 1] < eps) b[m - 1] = b[m - 1] + 2 * l;
  }
  sort(b, b + m);
  b[m ++] = 2 * l + b[0];
  //  for (int i = 0; i < m; i ++) cout << b[i] << endl;
  for (int i = 0; i < m - 1; i ++) {
    double mid = (b[i] + b[i + 1]) / 2;
    int s = findmin(mid);
    int t = findmax(mid + d);
    //cout << mid << " " << s << " " << t << endl;
    if (s >= 0 && t >= s)
      len[t - s + 1] += (b[i + 1] - b[i]);
    else len[0] += (b[i + 1] - b[i]);
  }
  for (int i = 0; i <= n / 2; i ++)
    fprintf(stdout, "%.9lf\n", len[i] / (2 * l));
  return 0;
}

int findmin(double x) {
  int lo = 0;
  int hi = n - 1;
  int res = -1;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (x < a[mid] || fabs(a[mid] - x) < eps) {
      res = mid;
      hi = mid - 1;
    }
    else lo = mid + 1;
  }
  return res;
}

int findmax(double x) {
  int lo = 0;
  int hi = n - 1;
  int res = -1;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (a[mid] < x || fabs(a[mid] - x) < eps) {
      res = mid;
      lo = mid + 1;
    }
    else hi = mid - 1;
  }
  return res;
}


#include <string>
#include <vector>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>

using namespace std;

int m, n, l, v1, v2;
double a[200002];
double b[200002];
double len[100001];
double d;
double eps = 1e-9;

int findmin(double);
int findmax(double);

int main() {
  cin >> n >> l >> v1 >> v2;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    a[n + i] = 2 * l + a[i];
  }
  n = n * 2;
  d = (double)v2 / double(v1 + v2) * double(l);
  m = 0;
  for (int i = 0; i < n / 2; i ++) {
    b[m ++] = a[i];
    b[m ++] = a[i] - d;
    if (b[m - 1] < eps) b[m - 1] = b[m - 1] + 2 * l;
  }
  b[m ++] = 2 * l + b[0];
  sort(b, b + m);
  //for (int i = 0; i < m; i ++) cout << b[i] << endl;
  for (int i = 0; i < m - 1; i ++) {
    double mid = (b[i] + b[i + 1]) / 2;
    int s = findmin(mid);
    int t = findmax(mid + d);
    //cout << mid << " " << s << " " << t << endl;
    if (s >= 0 && t >= s)
      len[t - s + 1] += (b[i + 1] - b[i]);
    else len[0] += (b[i + 1] - b[i]);
  }
  for (int i = 0; i <= n / 2; i ++)
    fprintf(stdout, "%.9lf\n", len[i] / (2 * l));
  return 0;
}

int findmin(double x) {
  int lo = 0;
  int hi = n - 1;
  int res = -1;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (x < a[mid] || fabs(a[mid] - x) < eps) {
      res = mid;
      hi = mid - 1;
    }
    else lo = mid + 1;
  }
  return res;
}

int findmax(double x) {
  int lo = 0;
  int hi = n - 1;
  int res = -1;
  while (lo <= hi) {
    int mid = (hi + lo) / 2;
    if (a[mid] < x || fabs(a[mid] - x) < eps) {
      res = mid;
      lo = mid + 1;
    }
    else hi = mid - 1;
  }
  return res;
}