#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;

typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;

#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b) - 1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a) - 1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define sz(x) (int)(x).size()
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert

const char nl = '\n';

vi primes, leastFac;
void compPrimes(int N) {
    leastFac = vi(N);
    leastFac[0]=1; leastFac[1] = 1;
    FOR(i,2,N) {
        if (leastFac[i] == 0) {
            primes.pb(i);
            leastFac[i] = i;
        }
        for (int j = 0; j < sz(primes) && i*primes[j] < N && primes[j] <= leastFac[i]; j++) {
            leastFac[i*primes[j]] = primes[j];
        }
    }
}

const int MX = 100010;
vi facs[MX];
vector<array<int, 3>> pf[MX];
int mob[MX];

void solve() {
    int N; cin >> N;
    compPrimes(N+10);

    FOR(i, 1, N+1) {
        for (int j = i*2; j <= N; j+=i) {
            facs[j].pb(i);
        }
        int v = i;
        mob[v] = -1;
        while (v != 1) {
            if (sz(pf[i]) && pf[i].back()[0] == leastFac[v]) {
                pf[i][sz(pf[i])-1][1]++;
                pf[i][sz(pf[i])-1][2] *= leastFac[v];
                mob[i] = 0;
            } else {
                pf[i].pb({leastFac[v], 1, leastFac[v]});
                mob[i] *= -1;
            }
            v /= leastFac[v];
        }
    }
    mob[1] = 0;

    ll WW[N]; F0R(i, N) cin >> WW[i];
    ll su = 0; F0R(i, N) su += WW[i];
    ld P[N+1]; F0R(i, N) P[i+1] = ((ld) WW[i]) / su;

    vd pSumMul[N+1];
    FOR(m, 1, N+1) {
        pSumMul[m] = vd(N/m + 1);
        FOR(i, 1, N/m + 1) {
            pSumMul[m][i] = P[i*m];
            trav(a, facs[i]) {
                pSumMul[m][i] += mob[i/a] * pSumMul[m][a];
            }
        }
    }


    ld Preach[N+1];
    Preach[1] = 1;
    ld ans = P[1] / (1 - P[1]);
    FOR(i, 2, N+1) {
        Preach[i] = 0;
        trav(a, facs[i]) {
            int p1 = 0, p2 = 0;
            int can = 1, must = 1;
            while (p1 < sz(pf[i])) {
                if (p2 < sz(pf[a]) && pf[i][p1][0] == pf[a][p2][0]) {
                    if (pf[i][p1][1] == pf[a][p2][1]) {
                        can *= pf[i][p1][2];
                    } else {
                        must *= pf[i][p1][2];
                    }
                    p1++; p2++;
                } else {
                    must *= pf[i][p1][2]; p1++;
                }
            }

            Preach[i] += Preach[a] * pSumMul[must][can] / (1 - pSumMul[1][a]);
        }

        ans += Preach[i] * (1 / (1 - pSumMul[1][i]));
    }

    cout << fixed << setprecision(15);
    cout << ans << nl;
    

}

int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	solve();
	return 0;
}