Exemple #1
0
def test_audio(systematic, log, sparse):

    n = 25
    d_v = 4
    d_c = 5
    seed = 0
    rnd = np.random.RandomState(seed)
    H, G = make_ldpc(n,
                     d_v,
                     d_c,
                     seed=seed,
                     systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()

    n, k = G.shape
    print(k)
    snr = 1000

    audio = rnd.randint(0, 255, size=5)
    audio_bin = audio2bin(audio)
    coded, noisy = ldpc_audio.encode_audio(G, audio_bin, snr, seed)
    x = ldpc_audio.decode_audio(G, H, coded, snr, maxiter=10, log=log)
    ber = ldpc_audio.ber_audio(audio_bin, audio2bin(x))
    assert ber == 0
Exemple #2
0
def test_image_rgb(systematic, log, sparse):

    n = 26
    d_v = 1
    d_c = 2
    seed = 0
    rnd = np.random.RandomState(seed)
    H, G = make_ldpc(n,
                     d_v,
                     d_c,
                     seed=seed,
                     systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()

    n, k = G.shape
    snr = 100

    img = rnd.randint(0, 255, size=(3, 3, 3))
    img_bin = rgb2bin(img)
    coded, noisy = ldpc_images.encode_img(G, img_bin, snr, seed)

    x = ldpc_images.decode_img(G, H, coded, snr, maxiter=100, log=log)

    assert ldpc_images.ber_img(img_bin, rgb2bin(x)) == 0
def test_image_gray(systematic, sparse):
    n = 100
    d_v = 3
    d_c = 4
    seed = 0
    rnd = np.random.RandomState(seed)
    H, G = make_ldpc(n,
                     d_v,
                     d_c,
                     seed=seed,
                     systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()

    n, k = G.shape
    snr = 10

    img = rnd.randint(0, 255, size=(3, 3))
    img_bin = gray2bin(img)
    img_shape = img_bin.shape

    coded, noisy = ldpc_images.encode_img(G, img_bin, snr, seed)

    x = ldpc_images.decode_img(G, H, coded, snr, img_shape=img_shape)

    assert ldpc_images.ber_img(img_bin, gray2bin(x)) == 0
Exemple #4
0
def test_decoding_did_not_converge(systematic, sparse):
    n = 15
    d_v = 4
    d_c = 5
    seed = 0

    H, G = make_ldpc(n, d_v, d_c, seed=seed, systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()

    n, k = G.shape
    snr = 1

    v = np.arange(k) % 2
    y = encode(G, v, snr, seed=seed)

    with pytest.warns(UserWarning, match="stopped before convergence"):
        decode(H, y, snr, maxiter=1)
Exemple #5
0
def test_decoding_random(systematic, sparse):
    n = 15
    d_v = 4
    d_c = 5
    seed = 0

    H, G = make_ldpc(n, d_v, d_c, seed=seed, systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()
    n, k = G.shape
    snr = 100

    v, y = encode_random_message(G, snr, seed)

    d = decode(H, y, snr)
    x = get_message(G, d)

    assert abs(v - x).sum() == 0
def test_audio(systematic, sparse):

    n = 48
    d_v = 2
    d_c = 3
    seed = 0
    rnd = np.random.RandomState(seed)
    H, G = make_ldpc(n,
                     d_v,
                     d_c,
                     seed=seed,
                     systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()

    n, k = G.shape
    snr = 10

    audio = rnd.randint(0, 255, size=2)
    audio_bin = audio2bin(audio)
    coded, noisy = ldpc_audio.encode_audio(G, audio_bin, snr, seed)
    x = ldpc_audio.decode_audio(G, H, coded, snr, audio_bin.shape)
    ber = ldpc_audio.ber_audio(audio_bin, audio2bin(x))
    assert ber == 0
Exemple #7
0
def test_decoding(systematic, log, sparse):
    n = 15
    d_v = 4
    d_c = 5
    seed = 0

    H, G = make_ldpc(n,
                     d_v,
                     d_c,
                     seed=seed,
                     systematic=systematic,
                     sparse=sparse)
    assert not binaryproduct(H, G).any()

    n, k = G.shape
    snr = 100

    v = np.arange(k) % 2
    y = encode(G, v, snr, seed)

    d = decode(H, y, snr, maxiter=10, log=log)
    x = get_message(G, d)

    assert abs(v - x).sum() == 0