import numpy
import math
import matplotlib.pyplot as plt


def ask(t, m):
    A1 = 0
    A2 = A

    if m == '0':
        return A1 * math.sin(2 * math.pi * fn * t / N)
    else:
        return A2 * math.sin(2 * math.pi * fn * t / N)


def fsk(t, m):
    fn1 = fn
    fn2 = 2 * fn

    if m == '0':
        return A * math.sin(2 * math.pi * fn1 * t / N)
    else:
        return A * math.sin(2 * math.pi * fn2 * t / N)


def psk(t, m):
    ph1 = 0
    ph2 = math.pi

    if m == '0':
        return A * math.sin(2 * math.pi * fn * t / N + ph1)
    else:
        return A * math.sin(2 * math.pi * fn * t / N + ph2)


def filteringASK(signal):
    tab = []

    for i in signal:
        tab.append(abs(i))

    return tab


def filteringPSK(signal):
    tab = []

    k = 0
    for i in numpy.arange(0, N, Tb):
        if signal[k+1] < 0:
            minus = 1
        else:
            minus = -1

        for j in numpy.arange(0, Tb, h):
            tab.append(minus * abs(signal[k]))
            k = k + 1

    return tab


def filteringFSK1(signal):
    tab = []

    for i in signal:
        tab.append(abs(i))

    return tab


def filteringFSK2(signal):
    tab = []

    for i in signal:
        tab.append(-abs(i))

    return tab


def smallSquare(signal, a, b):
    j = 0

    summary = 0
    for e in x:
        if e >= b - h:
            break

        if e < a:
            j = j + 1
            continue

        summary = summary + signal[j] * h
        j = j + 1

    return summary


m = '0110101101001101101100101101110111010110'

N = 2.0
Tb = N / len(m)
h = 0.001

A = 1
fn = N / Tb
ph = 0

x = numpy.arange(0, N, h)

ASK = []
FSK = []
PSK = []

index = 0
for i in x:
    index = int(i / Tb)

    ASK.append(ask(i, m[index]))
    FSK.append(fsk(i, m[index]))
    PSK.append(psk(i, m[index]))


filterASK = filteringASK(ASK)
filterPSK = filteringPSK(PSK)

pASK = []
pPSK = []

i = 0
while i < N:
    integralASK = smallSquare(filterASK, i, i + Tb)
    integralPSK = smallSquare(filterPSK, i, i + Tb)

    pASK.append(integralASK)
    pPSK.append(integralPSK)

    i = i + Tb

hASK = 0
hPSK = 0

mASK = []
mPSK = []

strASK = ''
strPSK = ''

for i in pASK:
    if i > hASK:
        bit = 1
    else:
        bit = 0

    strASK = strASK + str(bit)

    for j in numpy.arange(0, Tb, h):
        mASK.append(bit)

for i in pPSK:
    if i > hPSK:
        bit = 1
    else:
        bit = 0

    strPSK = strPSK + str(bit)

    for j in numpy.arange(0, Tb, h):
        mPSK.append(bit)

filterFSK1 = filteringFSK1(FSK)
filterFSK2 = filteringFSK2(FSK)

pFSK = []

i = 0
while i < N:
    a = round(i * 100) / 100
    b = round((i + Tb) * 100) / 100

    integralFSK1 = smallSquare(filterFSK1, a, b)
    integralFSK2 = smallSquare(filterFSK2, a, b)

    pFSK.append(round((integralFSK1 - integralFSK2) * math.pow(10, 5)) / math.pow(10, 5))

    print a, b, pFSK[-1]

    i = i + Tb

hFSK = 0.0633

mFSK = []
strFSK = ''

for i in pFSK:
    if i < hFSK:
        bit = 1
    else:
        bit = 0

    strFSK = strFSK + str(bit)

    for j in numpy.arange(0, Tb, h):
        mFSK.append(bit)