├── pc_simulate_launcher.sh
├── pc_construction_launcher.sh
├── MATLAB
    ├── mex_pc_decode.mexmaci64
    ├── mex_pc_encode.mexmaci64
    ├── pc_encode.m
    ├── pc_decode.m
    ├── pc_compile.m
    ├── get_bhattacharyya.m
    └── get_error_rate.m
├── PolarCodes.xcodeproj
    ├── project.xcworkspace
    │   └── contents.xcworkspacedata
    ├── xcuserdata
    │   └── Nicola.xcuserdatad
    │   │   └── xcschemes
    │   │       ├── xcschememanagement.plist
    │   │       └── PolarCodes.xcscheme
    └── project.pbxproj
├── PolarCodes
    ├── double_ei.h
    ├── pc_encode.h
    ├── pc_decode.h
    ├── pc_construction.h
    ├── pc_decode_internal.h
    ├── channels.h
    ├── polar_codes.h
    ├── error_rate.h
    ├── bhattacharyya_files.h
    ├── pc_encode.c
    ├── polar_codes.c
    ├── double_ei.c
    ├── pc_decode.c
    ├── channels.c
    ├── pc_decode_internal.c
    ├── pc_construction.c
    ├── error_rate.c
    └── bhattacharyya_files.c
├── qbatch_pc_construction.sh
├── qbatch_pc_simulate.sh
├── batch_pc_construction.sh
├── PCTest_double_ei
    ├── main.c
    └── Test_double_ei.1
├── test.sh
├── Makefile
├── PC_pc_construction
    ├── main.c
    └── pc_construction.1
├── PC_pc_simulate
    ├── pc_simulate.1
    └── main.c
└── .gitignore


/pc_simulate_launcher.sh:
--------------------------------------------------------------------------------
1 | 
2 | /home/ndf/pc/pc_simulate $*
3 | 


--------------------------------------------------------------------------------
/pc_construction_launcher.sh:
--------------------------------------------------------------------------------
1 | 
2 | /home/ndf/pc/pc_construction $*
3 | 


--------------------------------------------------------------------------------
/MATLAB/mex_pc_decode.mexmaci64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nicoladefranceschi/PolarCodes/HEAD/MATLAB/mex_pc_decode.mexmaci64


--------------------------------------------------------------------------------
/MATLAB/mex_pc_encode.mexmaci64:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nicoladefranceschi/PolarCodes/HEAD/MATLAB/mex_pc_encode.mexmaci64


--------------------------------------------------------------------------------
/PolarCodes.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:PolarCodes.xcodeproj">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/MATLAB/pc_encode.m:
--------------------------------------------------------------------------------
 1 | function [ x ] = pc_encode( u )
 2 | %PC_ENCODE_C Summary of this function goes here
 3 | %   Detailed explanation goes here
 4 | u=uint8(u);
 5 | x=uint8(zeros(size(u)));
 6 | for i=1:size(u,1)
 7 |     x(i,:)=mex_pc_encode(u(i,:));
 8 | end
 9 | 
10 | end
11 | 
12 | 


--------------------------------------------------------------------------------
/PolarCodes/double_ei.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  double_ei.h
 3 | //  
 4 | //
 5 | //  Created by Nicola De Franceschi on 25/10/13.
 6 | //
 7 | //
 8 | 
 9 | #ifndef double_ei_h
10 | #define double_ei_h
11 | 
12 | #include <stdio.h>
13 | 
14 | void   double_fput(FILE *out, double x);
15 | double double_fget(FILE *in);
16 | 
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/MATLAB/pc_decode.m:
--------------------------------------------------------------------------------
 1 | function [ u_ ] = pc_decode( y, ch_type, ch_par, A)
 2 | %PC_DECODE_C Summary of this function goes here
 3 | %   Detailed explanation goes here
 4 | 
 5 | y=uint8(y);
 6 | u_=uint8(zeros(size(y)));
 7 | for i=1:size(y,1)
 8 |     u_(i,:) = mex_pc_decode(y(i,:), ch_type, ch_par, uint8(A));
 9 | end
10 | 
11 | 
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/MATLAB/pc_compile.m:
--------------------------------------------------------------------------------
 1 | 
 2 | % compile mex files
 3 | 
 4 | 
 5 | 
 6 | mex ../PolarCodes/pc_encode_mex.c ../PolarCodes/pc_encode.c -output 'mex_pc_encode'
 7 | mex ../PolarCodes/pc_decode_mex.c ../PolarCodes/channels.c ../PolarCodes/polar_codes.c ../PolarCodes/pc_decode.c ../PolarCodes/pc_decode_internal.c  -output 'mex_pc_decode'
 8 | 
 9 | 
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_encode.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  pc_encode.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_pc_encode_h
10 | #define PolarCodes_pc_encode_h
11 | 
12 | #include "polar_codes.h"
13 | 
14 | 
15 | void pc_encode(Bit* xOut, Bit* u, u_int64_t n);
16 | 
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_decode.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  pc_decode.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_pc_decode_h
10 | #define PolarCodes_pc_decode_h
11 | 
12 | #include "polar_codes.h"
13 | #include "channels.h"
14 | 
15 | void pc_decode(Bit *u_, Bit *y, const Channel *channel, Bit *A, u_int64_t n);
16 | 
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_construction.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  pc_construction.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_pc_construction_h
10 | #define PolarCodes_pc_construction_h
11 | 
12 | #include "polar_codes.h"
13 | #include "channels.h"
14 | 
15 | 
16 | void pc_construction(double *Z, double *Zvar, u_int64_t n, const Channel *channel, u_int64_t n_samples);
17 | 
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/qbatch_pc_construction.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash          
 2 | 
 3 | HOMEDIR="/home/ndf/pc"
 4 | 
 5 | NN="8 9 10 11 12 13 14 15 16 17 18 19 20"
 6 | CH_TYPE="1"
 7 | CH_PAR="0.2 0.25 0.3 0.35 0.4 0.45"
 8 | 
 9 | N_SAMPLES=100
10 | MAX_N_SAMPLES=-1
11 | 
12 | OUTDIR="outputs/"
13 | 
14 | 
15 | for N in $NN; do
16 | 	for ctype in $CH_TYPE; do
17 | 		for cpar in $CH_PAR; do
18 | 			
19 | 			qsub $HOMEDIR/pc_construction_launcher.sh $N $ctype $cpar $N_SAMPLES $MAX_N_SAMPLES "$HOMEDIR/$OUTDIR"
20 | 			
21 | 		done
22 | 	done
23 | done
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/qbatch_pc_simulate.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash          
 2 | 
 3 | HOMEDIR="/home/ndf/pc"
 4 | 
 5 | NN="8 9 10 11 12 13 14 15 16 17 18 19 20"
 6 | CH_TYPE="1"
 7 | CH_PAR="0.2 0.25 0.3 0.35 0.4 0.45"
 8 | Kmin="0.1"
 9 | Kdelta="0.05"
10 | Kmax="0.5"
11 | 
12 | N_SAMPLES=100
13 | MAX_N_SAMPLES=-1
14 | 
15 | OUTDIR="outputs2/"
16 | 
17 | for N in $NN; do
18 | 	for ctype in $CH_TYPE; do
19 | 		for cpar in $CH_PAR; do
20 | 
21 | 			qsub $HOMEDIR/pc_simulate_launcher.sh $N $ctype $cpar $Kmin $Kdelta $Kmax $N_SAMPLES $MAX_N_SAMPLES "$HOMEDIR/$OUTDIR"
22 | 
23 | 		done
24 | 	done
25 | done
26 | 
27 | 
28 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_decode_internal.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  pc_decode_internal.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_pc_decode_internal_h
10 | #define PolarCodes_pc_decode_internal_h
11 | 
12 | #include "polar_codes.h"
13 | 
14 | 
15 | void pc_decode_calc_f(double *new_val, double *val, u_int64_t step, u_int64_t n);
16 | void pc_decode_calc_g(double *new_val, double *val, u_int64_t step, u_int64_t n, Bit *u, u_int64_t uindex);
17 | 
18 | 
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/batch_pc_construction.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash          
 2 | 
 3 | DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 4 | cd "$DIR"
 5 | 
 6 | NN="8 9 10 11 12 13 14 15 16 17 18 19 20"
 7 | CH_TYPE="1"
 8 | CH_PAR="0.2 0.25 0.3 0.35 0.4 0.45"
 9 | 
10 | N_SAMPLES=100
11 | MAX_N_SAMPLES=-1
12 | 
13 | OUTDIR="outputs/"
14 | 
15 | echo "Press any key to exit... "
16 | 
17 | for N in $NN; do
18 | 	for ctype in $CH_TYPE; do
19 | 		for cpar in $CH_PAR; do
20 | 			
21 | 			./pc_construction $N $ctype $cpar $N_SAMPLES $MAX_N_SAMPLES $OUTDIR > /dev/null & 
22 | 
23 | 		done
24 | 	done
25 | done
26 | 
27 | read -p "Press any key to exit... " -n1 -s
28 | 
29 | killall pc_construction
30 | 
31 | 


--------------------------------------------------------------------------------
/PCTest_double_ei/main.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //  main.c
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 25/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #include <stdio.h>
10 | 
11 | #include "../PolarCodes/double_ei.h"
12 | 
13 | int main(int argc, const char * argv[])
14 | {
15 | 
16 |     double d = 1234.0/(1<<5);
17 |     
18 |     printf("%f ",d);
19 |     
20 |     double_fput(stdout, d);
21 |     printf("\n");
22 |     
23 |     double i = double_fget(stdin);
24 |     double i2 = double_fget(stdin);
25 |     
26 |     printf("%f\n",i);
27 |     printf("%f\n",i2);
28 |     
29 |     
30 |     return 0;
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash          
 2 | 
 3 | DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 4 | cd "$DIR"
 5 | 
 6 | NN="8 9 10 11 12 13 14 15 16 17 18 19 20"
 7 | CH_TYPE="1"
 8 | CH_PAR="0.2 0.25 0.3 0.35 0.4 0.45"
 9 | 
10 | N_SAMPLES=100
11 | MAX_N_SAMPLES=-1
12 | 
13 | OUTDIR="outputs/"
14 | 
15 | echo "Press any key to exit... "
16 | 
17 | for N in $NN; do
18 | 	for ctype in $CH_TYPE; do
19 | 		for cpar in $CH_PAR; do
20 | 			
21 | 			./pc_construction $N $ctype $cpar $N_SAMPLES $MAX_N_SAMPLES $OUTDIR > /dev/null & 
22 | 
23 | 			cat
24 | 
25 | 			exit
26 | 
27 | 		done
28 | 	done
29 | done
30 | 
31 | read -p "Press any key to exit... " -n1 -s
32 | 
33 | killall pc_construction
34 | 
35 | 


--------------------------------------------------------------------------------
/PolarCodes/channels.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  channels.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_channels_h
10 | #define PolarCodes_channels_h
11 | 
12 | #include "polar_codes.h"
13 | 
14 | typedef enum {
15 |     ChannelType_BSC = 1,
16 |     ChannelType_BEC = 2
17 | } ChannelType;
18 | 
19 | 
20 | typedef struct {
21 |     ChannelType channel_type;
22 |     double par;
23 | } Channel;
24 | 
25 | 
26 | void apply_channel(Bit *yOut, Bit *x, const Channel *channel, u_int64_t n);
27 | 
28 | double channel_probability(const Channel *channel, Bit bOut, Bit bIn);
29 | 
30 | double channel_capacity(const Channel *channel);
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/MATLAB/get_bhattacharyya.m:
--------------------------------------------------------------------------------
 1 | function [ total_samples, Z, Zstd ] = get_bhattacharyya( fold, n, ch_type, ch_par )
 2 | %UNTITLED2 Summary of this function goes here
 3 | %   Detailed explanation goes here
 4 | 
 5 | ch_par_txt = num2str(ch_par,'%0.6f');
 6 | filename = [fold '/' 'bh_' num2str(n) '_ch_' num2str(ch_type) '_par_' ch_par_txt '.txt'];
 7 | 
 8 | fid = fopen(filename, 'r');
 9 | 
10 | if fid == -1
11 |     error 'no file'
12 | end
13 | total_samples=fscanf(fid, '%ld',1);
14 | 
15 | N=2^n;
16 | Z=zeros(1,N);
17 | Zvar=zeros(1,N);
18 | 
19 | for i=1:N
20 |     
21 |     Z(i)=double_fget(fid);
22 |     Zvar(i)=double_fget(fid);
23 |     
24 | end
25 | 
26 | Z=Z./double(total_samples);
27 | Zstd=sqrt( Zvar./double(total_samples) - Z.^2 );
28 | 
29 | fclose(fid);
30 | 
31 | end
32 | 
33 | 


--------------------------------------------------------------------------------
/PolarCodes/polar_codes.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  polar_codes.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_polar_codes_h
10 | #define PolarCodes_polar_codes_h
11 | 
12 | #include <stdlib.h>
13 | 
14 | 
15 | #define MIN_TRANSITION_PROBABILITY (1.0 / (double)(1 << 30))
16 | #define MAX_TRANSITION_PROBABILITY ((double)(1 << 30))
17 | 
18 | 
19 | typedef u_int8_t Bit;
20 | 
21 | 
22 | void random_bits(Bit *bits, u_int64_t N);
23 | void random_bits_f(Bit *bits, Bit *A, u_int64_t N);
24 | 
25 | void print_bits(Bit *bits, u_int64_t N);
26 | void print_doubles(double *doubles, u_int64_t N);
27 | 
28 | u_int64_t bit_reverse_index(u_int64_t index, u_int64_t n);
29 | 
30 | #endif
31 | 


--------------------------------------------------------------------------------
/PolarCodes/error_rate.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  error_rate.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 27/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_error_rate_h
10 | #define PolarCodes_error_rate_h
11 | 
12 | #include <stdio.h>
13 | #include <stdlib.h>
14 | #include "channels.h"
15 | 
16 | typedef struct {
17 |     u_int64_t n;
18 |     Channel channel;
19 |     u_int64_t K;
20 |     u_int64_t total_samples;
21 |     
22 |     double BER;
23 |     double BER_2;
24 | 
25 |     u_int64_t frame_errors;
26 |     
27 | } ErrorRate;
28 | 
29 | 
30 | void get_error_rate(ErrorRate *er, const char *dir, u_int64_t n, Channel *channel, u_int64_t K);
31 | void get_or_create_error_rate(ErrorRate *er, const char *dir, u_int64_t n, Channel *channel, u_int64_t K);
32 | void save_error_rate(ErrorRate *er, const char *dir);
33 | 
34 | 
35 | #endif
36 | 


--------------------------------------------------------------------------------
/PolarCodes/bhattacharyya_files.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  bhattacharyya_files.h
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 25/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #ifndef PolarCodes_bhattacharyya_files_h
10 | #define PolarCodes_bhattacharyya_files_h
11 | 
12 | #include <stdio.h>
13 | #include <stdlib.h>
14 | #include "channels.h"
15 | 
16 | typedef struct {
17 |     u_int64_t n;
18 |     Channel channel;
19 |     u_int64_t total_samples;
20 |     double *Z;
21 |     double *Zvar;
22 | } Bhattacharyya;
23 | 
24 | void get_bhattacharyya(Bhattacharyya *b, const char *dir, u_int64_t n, Channel *channel);
25 | void get_or_create_bhattacharyya(Bhattacharyya *b, const char *dir, u_int64_t n, Channel *channel);
26 | void save_bhattacharyya(Bhattacharyya *b, const char *dir);
27 | 
28 | void get_frozen_bits(Bit *bits, u_int64_t K, Bhattacharyya *b);
29 | 
30 | #endif
31 | 


--------------------------------------------------------------------------------
/MATLAB/get_error_rate.m:
--------------------------------------------------------------------------------
 1 | function [ total_samples, BER, BERstddev, frame_errors ] = get_error_rate( fold, n, ch_type, ch_par, K)
 2 | %GET_ERROR_RATE Summary of this function goes here
 3 | %   Detailed explanation goes here
 4 | %
 5 | %   GET_ERROR_RATE(dir, n, ch_type, ch_par, K) 
 6 | %
 7 | %   GET_ERROR_RATE(filename)
 8 | 
 9 | if nargin == 1
10 |     filename = fold;
11 | else
12 |     ch_par_txt = num2str(ch_par,'%0.6f');
13 |     filename = [fold '/' 'er_' num2str(n) '_ch_' num2str(ch_type) '_par_' ch_par_txt '_k_' num2str(K) '.txt'];
14 | end
15 | 
16 | fid = fopen(filename, 'r');
17 | 
18 | if fid == -1
19 |     error 'no file'
20 | end
21 | 
22 | total_samples=fscanf(fid, '%ld',1);
23 | BER=double_fget(fid);
24 | BER_2=double_fget(fid);
25 | frame_errors=fscanf(fid, '%ld',1);
26 | 
27 | fclose(fid);
28 | 
29 | 
30 | BER = BER / double(total_samples);
31 | BERstddev = sqrt( BER_2 / double(total_samples) - BER^2 );
32 | 
33 | end
34 | 
35 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_encode.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //  pc_encode.c
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #include <stdio.h>
10 | #include "pc_encode.h"
11 | #include <math.h>
12 | 
13 | void pc_encode(Bit* xOut, Bit* u, u_int64_t n) {
14 |     
15 |     u_int64_t N = 1 << n;
16 |     
17 |     Bit *in = u;
18 |     
19 |     u_int64_t step;
20 |     for(step = 1; step <= n; step++){
21 |         
22 |         u_int64_t group_size = 1 << step;
23 |         u_int64_t op_per_group = group_size >> 1;
24 |         
25 |         u_int64_t i;
26 |         for(i=0; i<N/2; i++){
27 |             
28 |             u_int64_t group_n = i/op_per_group;
29 |             u_int64_t index_in_group = i - op_per_group*group_n;
30 |             
31 |             u_int64_t i1 = group_n*group_size + index_in_group;
32 |             u_int64_t i2 = group_n*group_size + op_per_group + index_in_group;
33 |             
34 |             xOut[i1] = (in[i1] + in[i2]) & 1; //mod 2
35 |             xOut[i2] = in[i2]; //TODO: this is useless for step > 1
36 |         }
37 | 
38 |         in = xOut;
39 |         
40 |     }
41 | 
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | HEADERS = PolarCodes/bhattacharyya_files.h \
 3 | 		PolarCodes/channels.h \
 4 | 		PolarCodes/double_ei.h \
 5 | 		PolarCodes/pc_construction.h \
 6 | 		PolarCodes/pc_decode_internal.h \
 7 | 		PolarCodes/pc_decode.h \
 8 | 		PolarCodes/pc_encode.h \
 9 | 		PolarCodes/polar_codes.h \
10 | 		PolarCodes/error_rate.h
11 | 
12 | OBJECTS = PolarCodes/bhattacharyya_files.o \
13 | 	 	PolarCodes/channels.o \
14 | 	 	PolarCodes/double_ei.o \
15 | 	 	PolarCodes/pc_construction.o \
16 | 	 	PolarCodes/pc_decode_internal.o \
17 | 	 	PolarCodes/pc_decode.o \
18 | 	 	PolarCodes/pc_encode.o \
19 | 	 	PolarCodes/polar_codes.o \
20 | 	 	PolarCodes/error_rate.o
21 | 
22 | 
23 | MAIN_FILES = PC_pc_construction/main.o PC_pc_simulate/main.o
24 | 
25 | EXECUTABLES = pc_construction pc_simulate
26 | 
27 | 
28 | all: $(EXECUTABLES)
29 | default: all
30 | 
31 | 
32 | 
33 | pc_construction: $(OBJECTS) PC_pc_construction/main.o
34 | 	gcc $(OBJECTS) PC_pc_construction/main.o -lm -o $@
35 | 
36 | pc_simulate: $(OBJECTS) PC_pc_simulate/main.o
37 | 	gcc $(OBJECTS) PC_pc_simulate/main.o -lm -o $@
38 | 
39 | 
40 | 
41 | 
42 | %.o: %.c $(HEADERS)
43 | 	gcc -c $< -o $@
44 | 
45 | clean:
46 | 	-rm -f $(OBJECTS) $(MAIN_FILES)
47 | 	-rm -f $(EXECUTABLES)
48 | 
49 | 


--------------------------------------------------------------------------------
/PolarCodes/polar_codes.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //  polar_codes.c
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #include <stdio.h>
10 | #include "polar_codes.h"
11 | 
12 | 
13 | void random_bits(Bit *bits, u_int64_t N) {
14 |     u_int64_t i;
15 |     for(i=0; i<N; i++){
16 |         bits[i] = rand() & 1;
17 |     }
18 | }
19 | 
20 | void random_bits_f(Bit *bits, Bit *A, u_int64_t N) {
21 |     u_int64_t i;
22 |     for(i=0; i<N; i++){
23 |         if(A[i] == 0)
24 |             bits[i] = 0;
25 |         else
26 |             bits[i] = rand() & 1;        
27 |     }
28 | }
29 | 
30 | void print_bits(Bit *bits, u_int64_t N) {
31 |     
32 |     u_int64_t i;
33 |     for(i=0; i<N; printf(" "), i++){
34 |         if(bits[i] == 0)
35 |             printf("0");
36 |         else if(bits[i] == 1)
37 |             printf("1");
38 |         else
39 |             printf("?");
40 |     }
41 |     printf("\n");
42 |     
43 | }
44 | 
45 | void print_doubles(double *doubles, u_int64_t N) {
46 |     u_int64_t i;
47 |     for(i=0; i<N; printf(" "), i++){
48 |         printf("%f", doubles[i]);
49 |     }
50 |     printf("\n");
51 |     
52 | }
53 | 
54 | 
55 | u_int64_t bit_reverse_index(u_int64_t index, u_int64_t n) {
56 |     u_int64_t index2 = 0;
57 |     u_int64_t i;
58 |     for(i=0; i < n; i++){
59 |         index2 |= ((index >> i) & 1) << (n-i-1);
60 |     }
61 |     return index2;
62 | }
63 | 


--------------------------------------------------------------------------------
/PolarCodes.xcodeproj/xcuserdata/Nicola.xcuserdatad/xcschemes/xcschememanagement.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>SchemeUserState</key>
 6 | 	<dict>
 7 | 		<key>PolarCodes.xcscheme</key>
 8 | 		<dict>
 9 | 			<key>orderHint</key>
10 | 			<integer>0</integer>
11 | 		</dict>
12 | 		<key>Test_bec.xcscheme</key>
13 | 		<dict>
14 | 			<key>orderHint</key>
15 | 			<integer>4</integer>
16 | 		</dict>
17 | 		<key>Test_double_ei.xcscheme</key>
18 | 		<dict>
19 | 			<key>orderHint</key>
20 | 			<integer>1</integer>
21 | 		</dict>
22 | 		<key>pc_construction.xcscheme</key>
23 | 		<dict>
24 | 			<key>orderHint</key>
25 | 			<integer>2</integer>
26 | 		</dict>
27 | 		<key>pc_simulate.xcscheme</key>
28 | 		<dict>
29 | 			<key>orderHint</key>
30 | 			<integer>3</integer>
31 | 		</dict>
32 | 	</dict>
33 | 	<key>SuppressBuildableAutocreation</key>
34 | 	<dict>
35 | 		<key>B31E0A2A181CBCF100E941E5</key>
36 | 		<dict>
37 | 			<key>primary</key>
38 | 			<true/>
39 | 		</dict>
40 | 		<key>B3B7193B181B092300055AD4</key>
41 | 		<dict>
42 | 			<key>primary</key>
43 | 			<true/>
44 | 		</dict>
45 | 		<key>B3B71975181B0C5500055AD4</key>
46 | 		<dict>
47 | 			<key>primary</key>
48 | 			<true/>
49 | 		</dict>
50 | 		<key>B3B71991181B0CFC00055AD4</key>
51 | 		<dict>
52 | 			<key>primary</key>
53 | 			<true/>
54 | 		</dict>
55 | 		<key>B3E4D42F1843CE3700EAA309</key>
56 | 		<dict>
57 | 			<key>primary</key>
58 | 			<true/>
59 | 		</dict>
60 | 	</dict>
61 | </dict>
62 | </plist>
63 | 


--------------------------------------------------------------------------------
/PolarCodes/double_ei.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //  double_ei.c
 3 | //  
 4 | //
 5 | //  Created by Nicola De Franceschi on 25/10/13.
 6 | //
 7 | //
 8 | 
 9 | #include <stdio.h>
10 | #include <stdlib.h>
11 | #include <math.h>
12 | #include "double_ei.h"
13 | 
14 | 
15 | #define FRAC_MAX 9223372036854775807LL /* 2**63 - 1 */
16 | 
17 | 
18 | struct double_packed
19 | {
20 |     int exp;
21 |     long long frac;
22 | };
23 | 
24 | void double_pack(double x, struct double_packed *r);
25 | double double_unpack(const struct double_packed *p);
26 | 
27 | 
28 | void double_pack(double x, struct double_packed *r)
29 | {
30 |     double xf = fabs(frexp(x, &r->exp)) - 0.5;
31 |     
32 |     if (xf < 0.0)
33 |     {
34 |         r->frac = 0;
35 |         return;
36 |     }
37 |     
38 |     r->frac = 1 + (long long)(xf * 2.0 * (FRAC_MAX - 1));
39 |     
40 |     if (x < 0.0)
41 |         r->frac = -r->frac;
42 | }
43 | 
44 | double double_unpack(const struct double_packed *p)
45 | {
46 |     double xf, x;
47 |     
48 |     if (p->frac == 0)
49 |         return 0.0;
50 |     
51 |     xf = ((double)(llabs(p->frac) - 1) / (FRAC_MAX - 1)) / 2.0;
52 |     
53 |     x = ldexp(xf + 0.5, p->exp);
54 |     
55 |     if (p->frac < 0)
56 |         x = -x;
57 |     
58 |     return x;
59 | }
60 | 
61 | void double_fput(FILE *out, double x) {
62 |     struct double_packed dp;
63 |     double_pack(x, &dp);
64 |     fprintf(out, "%d %lld", dp.exp, dp.frac);
65 | }
66 | 
67 | double double_fget(FILE *in) {
68 |     struct double_packed dp;
69 |     int n = fscanf(in, "%d %lld", &dp.exp, &dp.frac);
70 |     if(n != 2)
71 |         exit(1);
72 |     return double_unpack(&dp);
73 | }
74 | 


--------------------------------------------------------------------------------
/PC_pc_construction/main.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //  main.c
 3 | //  pc_construction
 4 | //
 5 | //  Created by Nicola De Franceschi on 25/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #include <stdio.h>
10 | #include <stdlib.h>
11 | #include <string.h>
12 | #include <inttypes.h>
13 | #include <sys/time.h>
14 | #include "../PolarCodes/pc_construction.h"
15 | #include "../PolarCodes/bhattacharyya_files.h"
16 | 
17 | 
18 | #define DEFAULT_max_n_samples (1<<30)
19 | 
20 | 
21 | // call with arguments: n ch_type ch_par n_samples max_n_samples dir
22 | // max_n_samples==-1 for default
23 | int main(int argc, const char * argv[])
24 | {
25 |     
26 |     //random initialization
27 |     struct timeval time;
28 |     gettimeofday(&time,NULL);
29 |     srand((unsigned int)(time.tv_sec + time.tv_usec));
30 | 
31 |     
32 |     Channel channel;
33 |     u_int64_t n;
34 |     u_int64_t n_samples;
35 |     int64_t max_n_samples;
36 |     const char *dir;
37 |     
38 |     if(argc != 7)
39 |         exit(2);
40 |     
41 |     
42 |     //n
43 |     sscanf(argv[1], "%" PRIu64, &n);
44 |     
45 |     //ch_type
46 |     sscanf(argv[2], "%d", &(channel.channel_type));
47 | 
48 |     //ch_par
49 |     sscanf(argv[3], "%lf", &(channel.par));
50 |     
51 |     //n_samples
52 |     sscanf(argv[4], "%" PRIu64, &n_samples);
53 |     
54 |     //max_n_samples
55 |     sscanf(argv[5], "%" PRId64, &max_n_samples);
56 |     if(max_n_samples == -1)
57 |         max_n_samples=DEFAULT_max_n_samples;
58 | 
59 |     //dir
60 |     dir = argv[6];
61 |     
62 |     Bhattacharyya b;
63 |     get_or_create_bhattacharyya(&b, dir, n, &channel);
64 |     
65 |     while (1) {
66 |         
67 |         pc_construction(b.Z, b.Zvar, n, &(b.channel), n_samples);
68 |         b.total_samples += n_samples;
69 |         
70 |         save_bhattacharyya(&b, dir);
71 |         printf("total_samples = %lld\n", b.total_samples);
72 |         
73 |         if(b.total_samples > max_n_samples)
74 |             break;
75 |     }
76 |     
77 |     return 0;
78 | }
79 | 
80 | 
81 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_decode.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //  pc_decode.c
 3 | //  PolarCodes
 4 | //
 5 | //  Created by Nicola De Franceschi on 03/10/13.
 6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
 7 | //
 8 | 
 9 | #include <stdio.h>
10 | #include <string.h>
11 | #include <math.h>
12 | #include "pc_decode.h"
13 | #include "pc_decode_internal.h"
14 | 
15 | 
16 | void pc_decode_step(Bit *u_, Bit *A, u_int64_t n, u_int64_t step, double *val, u_int64_t *uindex);
17 | 
18 | 
19 | void pc_decode(Bit *u_, Bit *y, const Channel *channel, Bit *A, u_int64_t n) {
20 |     
21 |     u_int64_t N = 1 << n;
22 |     u_int64_t uindex = 0;
23 |     
24 |     double *delta = malloc(N*sizeof(double));
25 |     u_int64_t i;
26 |     for(i = 0; i < N; i++){
27 |         
28 |         u_int64_t i2 = bit_reverse_index(i, n);
29 |         double n,d,v;
30 |         
31 |         n = channel_probability(channel, y[i2], 0);
32 |         d = channel_probability(channel, y[i2], 1);
33 |         
34 |         if(d == 0){
35 |             v = MAX_TRANSITION_PROBABILITY;
36 |         }else{
37 |             v = n/d;
38 |             if(v < MIN_TRANSITION_PROBABILITY){
39 |                 v = MIN_TRANSITION_PROBABILITY;
40 |             }else if(v > MAX_TRANSITION_PROBABILITY){
41 |                 v = MAX_TRANSITION_PROBABILITY;
42 |             }
43 |         }
44 |         
45 |         delta[i] = v;
46 |         
47 |     }
48 |     
49 |     pc_decode_step(u_, A, n, 1, delta, &uindex);
50 |     
51 |     free(delta);
52 |     
53 | }
54 | 
55 | void pc_decode_update_u_(Bit *u_, Bit *A, double v, u_int64_t *uindex){
56 |     
57 |     if(A[*uindex] == 0){
58 |         u_[*uindex] = 0;
59 |     }else if(v >= 1){
60 |         u_[*uindex] = 0;
61 |     }else{
62 |         u_[*uindex] = 1;
63 |     }
64 |     
65 |     (*uindex)++;
66 | }
67 | 
68 | void pc_decode_step(Bit *u_, Bit *A, u_int64_t n, u_int64_t step, double *val, u_int64_t *uindex){
69 |     
70 |     u_int64_t D = 1 << (n-step);
71 |     double *new_val = malloc(sizeof(double)*D);
72 |     
73 |     //calcolate f
74 |     pc_decode_calc_f(new_val, val, step, n);
75 |     
76 |     if(step == n){
77 |         pc_decode_update_u_(u_, A, new_val[0], uindex);
78 |     }else{
79 |         pc_decode_step(u_, A, n, step+1, new_val, uindex);
80 |     }
81 |     
82 |     
83 |     //calcolate f
84 |     pc_decode_calc_g(new_val, val, step, n, u_, *uindex);
85 |     
86 |     if(step == n){
87 |         pc_decode_update_u_(u_, A, new_val[0], uindex);
88 |     }else{
89 |         pc_decode_step(u_, A, n, step+1, new_val, uindex);
90 |     }
91 |     
92 |     free(new_val);
93 | }
94 | 
95 | 
96 | 


--------------------------------------------------------------------------------
/PolarCodes/channels.c:
--------------------------------------------------------------------------------
  1 | //
  2 | //  channels.c
  3 | //  PolarCodes
  4 | //
  5 | //  Created by Nicola De Franceschi on 03/10/13.
  6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
  7 | //
  8 | 
  9 | #include <stdio.h>
 10 | #include "channels.h"
 11 | #include <math.h>
 12 | 
 13 | 
 14 | void apply_channel(Bit *yOut, Bit *x, const Channel *channel, u_int64_t n) {
 15 |     
 16 |     switch (channel->channel_type) {
 17 |             
 18 |         case ChannelType_BSC:
 19 |         {
 20 |             u_int64_t N = 1 << n;
 21 |             
 22 |             u_int64_t i;
 23 |             for(i=0; i<N; i++){
 24 |                 
 25 |                 double r = (double)rand() / (double)RAND_MAX;
 26 |                 
 27 |                 if(r < channel->par)
 28 |                     yOut[i] = (x[i] + 1) & 1;
 29 |                 else
 30 |                     yOut[i] = x[i];
 31 |                 
 32 |             }
 33 |             
 34 |             break;
 35 |         }
 36 |             
 37 |         case ChannelType_BEC:
 38 |         {
 39 |             
 40 |             u_int64_t N = 1 << n;
 41 |             
 42 |             u_int64_t i;
 43 |             for(i=0; i<N; i++){
 44 |                 
 45 |                 double r = (double)rand() / (double)RAND_MAX;
 46 |                 
 47 |                 if(r < channel->par)
 48 |                     yOut[i] = 2;
 49 |                 else
 50 |                     yOut[i] = x[i];
 51 |                 
 52 |             }
 53 |             
 54 |             break;
 55 |         }
 56 |             
 57 |     }
 58 |  
 59 | }
 60 | 
 61 | double channel_probability(const Channel *channel, Bit bOut, Bit bIn) {
 62 | 
 63 |     switch (channel->channel_type) {
 64 |         case ChannelType_BSC:
 65 |         {
 66 |             if(bOut != bIn)
 67 |                 return channel->par;
 68 |             else
 69 |                 return 1-channel->par;
 70 |         }
 71 |             
 72 |         case ChannelType_BEC:
 73 |         {
 74 |             if(bOut == 2)
 75 |                 return channel->par;
 76 |             else if(bOut == bIn)
 77 |                 return 1-channel->par;
 78 |             else
 79 |                 return 0;
 80 |             
 81 |         }
 82 |     }
 83 | 
 84 | }
 85 | 
 86 | double channel_capacity(const Channel *channel) {
 87 |     
 88 |     switch (channel->channel_type) {
 89 |         case ChannelType_BSC:
 90 |         {
 91 |             double entropy = - channel->par*log2(channel->par) - (1-channel->par)*log2(1-channel->par);
 92 |             return 1-entropy;
 93 |         }
 94 |         
 95 |         case ChannelType_BEC:
 96 |         {
 97 |             return 1-channel->par;
 98 |         }
 99 |     }
100 |     
101 | }
102 | 
103 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_decode_internal.c:
--------------------------------------------------------------------------------
  1 | //
  2 | //  pc_decode_internal.c
  3 | //  PolarCodes
  4 | //
  5 | //  Created by Nicola De Franceschi on 16/10/13.
  6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
  7 | //
  8 | 
  9 | #include <stdio.h>
 10 | #include <string.h>
 11 | #include "pc_decode_internal.h"
 12 | 
 13 | void pc_decode_calc_f(double *new_val, double *val, u_int64_t step, u_int64_t n) {
 14 |     
 15 |     u_int64_t D = 1 << (n-step);
 16 |     
 17 |     u_int64_t i;
 18 |     for(i = 0; i < D; i++){
 19 |         double a = val[2*i];
 20 |         double b = val[2*i+1];
 21 |         
 22 |         double v = (1+a*b) / (a+b);
 23 |         
 24 |         if(v < MIN_TRANSITION_PROBABILITY){
 25 |             v = MIN_TRANSITION_PROBABILITY;
 26 |         }else if(v > MAX_TRANSITION_PROBABILITY){
 27 |             v = MAX_TRANSITION_PROBABILITY;
 28 |         }
 29 |         
 30 |         new_val[i] = v;
 31 |         
 32 |     }
 33 |     
 34 | }
 35 | 
 36 | void pc_decode_calc_us(Bit *usOut, u_int64_t stage, Bit *u, u_int64_t uindex){
 37 |     
 38 |     u_int64_t dim = 1 << stage;
 39 |     u_int64_t dim2 = 1;
 40 |     
 41 |     memcpy(usOut, u + uindex - dim, dim);
 42 |     
 43 |     u_int64_t s;
 44 |     
 45 |     Bit *temp2 = malloc(dim*sizeof(Bit));
 46 |     
 47 |     for(s = 1; s <= stage; s++){
 48 |         
 49 |         u_int64_t i1, i2;
 50 |         for(i1 = 0; i1 < 1<<(stage-s); i1++){
 51 |             for(i2 = 0; i2 < 1<<(s-1); i2++){
 52 |                 
 53 |                 Bit even = usOut[(2*i1+1)*dim2+i2]; //even in matlab!
 54 |                 Bit odd = usOut[(2*i1)*dim2+i2]; //even in matlab!
 55 |                 
 56 |                 temp2[i1*dim2*2 + i2*2] = (even + odd) & 1;
 57 |                 temp2[i1*dim2*2 + i2*2+1] = even;
 58 |                 
 59 |             }
 60 |         }
 61 |         
 62 |         dim2 *= 2;
 63 |         
 64 |         memcpy(usOut, temp2, dim);
 65 |         
 66 |     }
 67 |     
 68 |     free(temp2);
 69 |     
 70 | }
 71 | 
 72 | void pc_decode_calc_g(double *new_val, double *val, u_int64_t step, u_int64_t n, Bit *u, u_int64_t uindex) {
 73 |     
 74 |     
 75 |     u_int64_t D = 1 << (n-step);
 76 |     
 77 |     u_int64_t i;
 78 |     
 79 |     Bit us[D];
 80 |     pc_decode_calc_us(us, n-step, u, uindex);
 81 |     
 82 |     for(i = 0; i < D; i++){
 83 |         double a = val[2*i];
 84 |         double b = val[2*i+1];
 85 |         double v;
 86 |         
 87 |         if(us[i] == 0){
 88 |             v = b*a;
 89 |         }else{
 90 |             v = b/a;
 91 |         }
 92 |         
 93 |         if(v < MIN_TRANSITION_PROBABILITY){
 94 |             v = MIN_TRANSITION_PROBABILITY;
 95 |         }else if(v > MAX_TRANSITION_PROBABILITY){
 96 |             v = MAX_TRANSITION_PROBABILITY;
 97 |         }
 98 |         
 99 |         new_val[i] = v;
100 |         
101 |     }
102 |     
103 | }
104 | 


--------------------------------------------------------------------------------
/PC_pc_simulate/pc_simulate.1:
--------------------------------------------------------------------------------
 1 | .\"Modified from man(1) of FreeBSD, the NetBSD mdoc.template, and mdoc.samples.
 2 | .\"See Also:
 3 | .\"man mdoc.samples for a complete listing of options
 4 | .\"man mdoc for the short list of editing options
 5 | .\"/usr/share/misc/mdoc.template
 6 | .Dd 26/10/13               \" DATE 
 7 | .Dt pc_simulate 1      \" Program name and manual section number 
 8 | .Os Darwin
 9 | .Sh NAME                 \" Section Header - required - don't modify 
10 | .Nm pc_simulate,
11 | .\" The following lines are read in generating the apropos(man -k) database. Use only key
12 | .\" words here as the database is built based on the words here and in the .ND line. 
13 | .Nm Other_name_for_same_program(),
14 | .Nm Yet another name for the same program.
15 | .\" Use .Nm macro to designate other names for the documented program.
16 | .Nd This line parsed for whatis database.
17 | .Sh SYNOPSIS             \" Section Header - required - don't modify
18 | .Nm
19 | .Op Fl abcd              \" [-abcd]
20 | .Op Fl a Ar path         \" [-a path] 
21 | .Op Ar file              \" [file]
22 | .Op Ar                   \" [file ...]
23 | .Ar arg0                 \" Underlined argument - use .Ar anywhere to underline
24 | arg2 ...                 \" Arguments
25 | .Sh DESCRIPTION          \" Section Header - required - don't modify
26 | Use the .Nm macro to refer to your program throughout the man page like such:
27 | .Nm
28 | Underlining is accomplished with the .Ar macro like this:
29 | .Ar underlined text .
30 | .Pp                      \" Inserts a space
31 | A list of items with descriptions:
32 | .Bl -tag -width -indent  \" Begins a tagged list 
33 | .It item a               \" Each item preceded by .It macro
34 | Description of item a
35 | .It item b
36 | Description of item b
37 | .El                      \" Ends the list
38 | .Pp
39 | A list of flags and their descriptions:
40 | .Bl -tag -width -indent  \" Differs from above in tag removed 
41 | .It Fl a                 \"-a flag as a list item
42 | Description of -a flag
43 | .It Fl b
44 | Description of -b flag
45 | .El                      \" Ends the list
46 | .Pp
47 | .\" .Sh ENVIRONMENT      \" May not be needed
48 | .\" .Bl -tag -width "ENV_VAR_1" -indent \" ENV_VAR_1 is width of the string ENV_VAR_1
49 | .\" .It Ev ENV_VAR_1
50 | .\" Description of ENV_VAR_1
51 | .\" .It Ev ENV_VAR_2
52 | .\" Description of ENV_VAR_2
53 | .\" .El                      
54 | .Sh FILES                \" File used or created by the topic of the man page
55 | .Bl -tag -width "/Users/joeuser/Library/really_long_file_name" -compact
56 | .It Pa /usr/share/file_name
57 | FILE_1 description
58 | .It Pa /Users/joeuser/Library/really_long_file_name
59 | FILE_2 description
60 | .El                      \" Ends the list
61 | .\" .Sh DIAGNOSTICS       \" May not be needed
62 | .\" .Bl -diag
63 | .\" .It Diagnostic Tag
64 | .\" Diagnostic informtion here.
65 | .\" .It Diagnostic Tag
66 | .\" Diagnostic informtion here.
67 | .\" .El
68 | .Sh SEE ALSO 
69 | .\" List links in ascending order by section, alphabetically within a section.
70 | .\" Please do not reference files that do not exist without filing a bug report
71 | .Xr a 1 , 
72 | .Xr b 1 ,
73 | .Xr c 1 ,
74 | .Xr a 2 ,
75 | .Xr b 2 ,
76 | .Xr a 3 ,
77 | .Xr b 3 
78 | .\" .Sh BUGS              \" Document known, unremedied bugs 
79 | .\" .Sh HISTORY           \" Document history if command behaves in a unique manner


--------------------------------------------------------------------------------
/PCTest_double_ei/Test_double_ei.1:
--------------------------------------------------------------------------------
 1 | .\"Modified from man(1) of FreeBSD, the NetBSD mdoc.template, and mdoc.samples.
 2 | .\"See Also:
 3 | .\"man mdoc.samples for a complete listing of options
 4 | .\"man mdoc for the short list of editing options
 5 | .\"/usr/share/misc/mdoc.template
 6 | .Dd 25/10/13               \" DATE 
 7 | .Dt Test_double_ei 1      \" Program name and manual section number 
 8 | .Os Darwin
 9 | .Sh NAME                 \" Section Header - required - don't modify 
10 | .Nm Test_double_ei,
11 | .\" The following lines are read in generating the apropos(man -k) database. Use only key
12 | .\" words here as the database is built based on the words here and in the .ND line. 
13 | .Nm Other_name_for_same_program(),
14 | .Nm Yet another name for the same program.
15 | .\" Use .Nm macro to designate other names for the documented program.
16 | .Nd This line parsed for whatis database.
17 | .Sh SYNOPSIS             \" Section Header - required - don't modify
18 | .Nm
19 | .Op Fl abcd              \" [-abcd]
20 | .Op Fl a Ar path         \" [-a path] 
21 | .Op Ar file              \" [file]
22 | .Op Ar                   \" [file ...]
23 | .Ar arg0                 \" Underlined argument - use .Ar anywhere to underline
24 | arg2 ...                 \" Arguments
25 | .Sh DESCRIPTION          \" Section Header - required - don't modify
26 | Use the .Nm macro to refer to your program throughout the man page like such:
27 | .Nm
28 | Underlining is accomplished with the .Ar macro like this:
29 | .Ar underlined text .
30 | .Pp                      \" Inserts a space
31 | A list of items with descriptions:
32 | .Bl -tag -width -indent  \" Begins a tagged list 
33 | .It item a               \" Each item preceded by .It macro
34 | Description of item a
35 | .It item b
36 | Description of item b
37 | .El                      \" Ends the list
38 | .Pp
39 | A list of flags and their descriptions:
40 | .Bl -tag -width -indent  \" Differs from above in tag removed 
41 | .It Fl a                 \"-a flag as a list item
42 | Description of -a flag
43 | .It Fl b
44 | Description of -b flag
45 | .El                      \" Ends the list
46 | .Pp
47 | .\" .Sh ENVIRONMENT      \" May not be needed
48 | .\" .Bl -tag -width "ENV_VAR_1" -indent \" ENV_VAR_1 is width of the string ENV_VAR_1
49 | .\" .It Ev ENV_VAR_1
50 | .\" Description of ENV_VAR_1
51 | .\" .It Ev ENV_VAR_2
52 | .\" Description of ENV_VAR_2
53 | .\" .El                      
54 | .Sh FILES                \" File used or created by the topic of the man page
55 | .Bl -tag -width "/Users/joeuser/Library/really_long_file_name" -compact
56 | .It Pa /usr/share/file_name
57 | FILE_1 description
58 | .It Pa /Users/joeuser/Library/really_long_file_name
59 | FILE_2 description
60 | .El                      \" Ends the list
61 | .\" .Sh DIAGNOSTICS       \" May not be needed
62 | .\" .Bl -diag
63 | .\" .It Diagnostic Tag
64 | .\" Diagnostic informtion here.
65 | .\" .It Diagnostic Tag
66 | .\" Diagnostic informtion here.
67 | .\" .El
68 | .Sh SEE ALSO 
69 | .\" List links in ascending order by section, alphabetically within a section.
70 | .\" Please do not reference files that do not exist without filing a bug report
71 | .Xr a 1 , 
72 | .Xr b 1 ,
73 | .Xr c 1 ,
74 | .Xr a 2 ,
75 | .Xr b 2 ,
76 | .Xr a 3 ,
77 | .Xr b 3 
78 | .\" .Sh BUGS              \" Document known, unremedied bugs 
79 | .\" .Sh HISTORY           \" Document history if command behaves in a unique manner


--------------------------------------------------------------------------------
/PC_pc_construction/pc_construction.1:
--------------------------------------------------------------------------------
 1 | .\"Modified from man(1) of FreeBSD, the NetBSD mdoc.template, and mdoc.samples.
 2 | .\"See Also:
 3 | .\"man mdoc.samples for a complete listing of options
 4 | .\"man mdoc for the short list of editing options
 5 | .\"/usr/share/misc/mdoc.template
 6 | .Dd 25/10/13               \" DATE 
 7 | .Dt pc_construction 1      \" Program name and manual section number 
 8 | .Os Darwin
 9 | .Sh NAME                 \" Section Header - required - don't modify 
10 | .Nm pc_construction,
11 | .\" The following lines are read in generating the apropos(man -k) database. Use only key
12 | .\" words here as the database is built based on the words here and in the .ND line. 
13 | .Nm Other_name_for_same_program(),
14 | .Nm Yet another name for the same program.
15 | .\" Use .Nm macro to designate other names for the documented program.
16 | .Nd This line parsed for whatis database.
17 | .Sh SYNOPSIS             \" Section Header - required - don't modify
18 | .Nm
19 | .Op Fl abcd              \" [-abcd]
20 | .Op Fl a Ar path         \" [-a path] 
21 | .Op Ar file              \" [file]
22 | .Op Ar                   \" [file ...]
23 | .Ar arg0                 \" Underlined argument - use .Ar anywhere to underline
24 | arg2 ...                 \" Arguments
25 | .Sh DESCRIPTION          \" Section Header - required - don't modify
26 | Use the .Nm macro to refer to your program throughout the man page like such:
27 | .Nm
28 | Underlining is accomplished with the .Ar macro like this:
29 | .Ar underlined text .
30 | .Pp                      \" Inserts a space
31 | A list of items with descriptions:
32 | .Bl -tag -width -indent  \" Begins a tagged list 
33 | .It item a               \" Each item preceded by .It macro
34 | Description of item a
35 | .It item b
36 | Description of item b
37 | .El                      \" Ends the list
38 | .Pp
39 | A list of flags and their descriptions:
40 | .Bl -tag -width -indent  \" Differs from above in tag removed 
41 | .It Fl a                 \"-a flag as a list item
42 | Description of -a flag
43 | .It Fl b
44 | Description of -b flag
45 | .El                      \" Ends the list
46 | .Pp
47 | .\" .Sh ENVIRONMENT      \" May not be needed
48 | .\" .Bl -tag -width "ENV_VAR_1" -indent \" ENV_VAR_1 is width of the string ENV_VAR_1
49 | .\" .It Ev ENV_VAR_1
50 | .\" Description of ENV_VAR_1
51 | .\" .It Ev ENV_VAR_2
52 | .\" Description of ENV_VAR_2
53 | .\" .El                      
54 | .Sh FILES                \" File used or created by the topic of the man page
55 | .Bl -tag -width "/Users/joeuser/Library/really_long_file_name" -compact
56 | .It Pa /usr/share/file_name
57 | FILE_1 description
58 | .It Pa /Users/joeuser/Library/really_long_file_name
59 | FILE_2 description
60 | .El                      \" Ends the list
61 | .\" .Sh DIAGNOSTICS       \" May not be needed
62 | .\" .Bl -diag
63 | .\" .It Diagnostic Tag
64 | .\" Diagnostic informtion here.
65 | .\" .It Diagnostic Tag
66 | .\" Diagnostic informtion here.
67 | .\" .El
68 | .Sh SEE ALSO 
69 | .\" List links in ascending order by section, alphabetically within a section.
70 | .\" Please do not reference files that do not exist without filing a bug report
71 | .Xr a 1 , 
72 | .Xr b 1 ,
73 | .Xr c 1 ,
74 | .Xr a 2 ,
75 | .Xr b 2 ,
76 | .Xr a 3 ,
77 | .Xr b 3 
78 | .\" .Sh BUGS              \" Document known, unremedied bugs 
79 | .\" .Sh HISTORY           \" Document history if command behaves in a unique manner


--------------------------------------------------------------------------------
/PolarCodes.xcodeproj/xcuserdata/Nicola.xcuserdatad/xcschemes/PolarCodes.xcscheme:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Scheme
 3 |    LastUpgradeVersion = "0500"
 4 |    version = "1.3">
 5 |    <BuildAction
 6 |       parallelizeBuildables = "YES"
 7 |       buildImplicitDependencies = "YES">
 8 |       <BuildActionEntries>
 9 |          <BuildActionEntry
10 |             buildForTesting = "YES"
11 |             buildForRunning = "YES"
12 |             buildForProfiling = "YES"
13 |             buildForArchiving = "YES"
14 |             buildForAnalyzing = "YES">
15 |             <BuildableReference
16 |                BuildableIdentifier = "primary"
17 |                BlueprintIdentifier = "B3B7193B181B092300055AD4"
18 |                BuildableName = "PolarCodes"
19 |                BlueprintName = "PolarCodes"
20 |                ReferencedContainer = "container:PolarCodes.xcodeproj">
21 |             </BuildableReference>
22 |          </BuildActionEntry>
23 |       </BuildActionEntries>
24 |    </BuildAction>
25 |    <TestAction
26 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
27 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
28 |       shouldUseLaunchSchemeArgsEnv = "YES"
29 |       buildConfiguration = "Debug">
30 |       <Testables>
31 |       </Testables>
32 |       <MacroExpansion>
33 |          <BuildableReference
34 |             BuildableIdentifier = "primary"
35 |             BlueprintIdentifier = "B3B7193B181B092300055AD4"
36 |             BuildableName = "PolarCodes"
37 |             BlueprintName = "PolarCodes"
38 |             ReferencedContainer = "container:PolarCodes.xcodeproj">
39 |          </BuildableReference>
40 |       </MacroExpansion>
41 |    </TestAction>
42 |    <LaunchAction
43 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
44 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
45 |       launchStyle = "0"
46 |       useCustomWorkingDirectory = "NO"
47 |       buildConfiguration = "Debug"
48 |       ignoresPersistentStateOnLaunch = "NO"
49 |       debugDocumentVersioning = "YES"
50 |       allowLocationSimulation = "YES">
51 |       <BuildableProductRunnable>
52 |          <BuildableReference
53 |             BuildableIdentifier = "primary"
54 |             BlueprintIdentifier = "B3B7193B181B092300055AD4"
55 |             BuildableName = "PolarCodes"
56 |             BlueprintName = "PolarCodes"
57 |             ReferencedContainer = "container:PolarCodes.xcodeproj">
58 |          </BuildableReference>
59 |       </BuildableProductRunnable>
60 |       <AdditionalOptions>
61 |       </AdditionalOptions>
62 |    </LaunchAction>
63 |    <ProfileAction
64 |       shouldUseLaunchSchemeArgsEnv = "YES"
65 |       savedToolIdentifier = ""
66 |       useCustomWorkingDirectory = "NO"
67 |       buildConfiguration = "Release"
68 |       debugDocumentVersioning = "YES">
69 |       <BuildableProductRunnable>
70 |          <BuildableReference
71 |             BuildableIdentifier = "primary"
72 |             BlueprintIdentifier = "B3B7193B181B092300055AD4"
73 |             BuildableName = "PolarCodes"
74 |             BlueprintName = "PolarCodes"
75 |             ReferencedContainer = "container:PolarCodes.xcodeproj">
76 |          </BuildableReference>
77 |       </BuildableProductRunnable>
78 |    </ProfileAction>
79 |    <AnalyzeAction
80 |       buildConfiguration = "Debug">
81 |    </AnalyzeAction>
82 |    <ArchiveAction
83 |       buildConfiguration = "Release"
84 |       revealArchiveInOrganizer = "YES">
85 |    </ArchiveAction>
86 | </Scheme>
87 | 


--------------------------------------------------------------------------------
/PolarCodes/pc_construction.c:
--------------------------------------------------------------------------------
  1 | //
  2 | //  pc_construction.c
  3 | //  PolarCodes
  4 | //
  5 | //  Created by Nicola De Franceschi on 03/10/13.
  6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
  7 | //
  8 | 
  9 | #include <stdio.h>
 10 | #include <string.h>
 11 | #include <math.h>
 12 | #include "pc_construction.h"
 13 | #include "pc_encode.h"
 14 | #include "pc_decode_internal.h"
 15 | 
 16 | /*
 17 | int pc_sort_cmp(const void *x, const void *y)
 18 | {
 19 |     double xx = *(double*)x, yy = *(double*)y;
 20 |     if (xx < yy) return 1;
 21 |     if (xx > yy) return -1;
 22 |     return 0;
 23 | }
 24 | */
 25 | 
 26 | void pc_decode_construction_step(double *Z, double *Zvar, Bit *u, u_int64_t n, u_int64_t step, double *val, u_int64_t *uindex);
 27 | void pc_decode_construction(double *Z, double *Zvar, Bit *y, const Channel *channel, Bit *u, u_int64_t n);
 28 | 
 29 | 
 30 | void pc_construction(double *Z, double *Zvar, u_int64_t n, const Channel *channel, u_int64_t n_samples) {
 31 |     
 32 |     u_int64_t N = 1 << n;
 33 |     
 34 | //    memset(Z, 0, sizeof(double)*N);
 35 | //    memset(Zvar, 0, sizeof(double)*N);
 36 |     
 37 |     u_int64_t i;
 38 |     Bit *u = malloc(N*sizeof(Bit));
 39 |     Bit *x = malloc(N*sizeof(Bit));
 40 |     for(i = 0; i < n_samples; i++){
 41 |         
 42 |         //printf("samples: %d\n",i);
 43 |         
 44 |         random_bits(u, N);
 45 |         
 46 |         pc_encode(x, u, n);
 47 |         
 48 |         Bit *y = x;
 49 |         apply_channel(y, x, channel, n);
 50 |         
 51 |         pc_decode_construction(Z, Zvar, y, channel, u, n);
 52 |         
 53 |     }
 54 |     
 55 |     free(u);
 56 |     free(x);
 57 |     
 58 | //    qsort(Z, N, sizeof(double), &pc_sort_cmp);
 59 |     
 60 | //    [Z,I]=sort(Z_sum,'descend');
 61 |   //  A(I(1:N-K))=0;
 62 |     
 63 |     
 64 | 
 65 | }
 66 | 
 67 | 
 68 | void pc_decode_construction(double *Z, double *Zvar, Bit *y, const Channel *channel, Bit *u, u_int64_t n) {
 69 |     
 70 |     u_int64_t N = 1 << n;
 71 |     u_int64_t uindex = 0;
 72 |     
 73 |     double *delta = malloc(N*sizeof(double));
 74 | 
 75 |     u_int64_t i;
 76 |     for(i = 0; i < N; i++){
 77 |         
 78 |         u_int64_t i2 = bit_reverse_index(i, n);
 79 |         double n_,d_,v;
 80 |         
 81 |         n_ = channel_probability(channel, y[i2], 0);
 82 |         d_ = channel_probability(channel, y[i2], 1);
 83 |         
 84 |         if(d_ == 0){
 85 |             v = MAX_TRANSITION_PROBABILITY;
 86 |         }else{
 87 |             v = n_/d_;
 88 |             if(v < MIN_TRANSITION_PROBABILITY){
 89 |                 v = MIN_TRANSITION_PROBABILITY;
 90 |             }else if(v > MAX_TRANSITION_PROBABILITY){
 91 |                 v = MAX_TRANSITION_PROBABILITY;
 92 |             }
 93 |         }
 94 |         
 95 |         delta[i] = v;
 96 |         
 97 |     }
 98 |     
 99 |     pc_decode_construction_step(Z, Zvar, u, n, 1, delta, &uindex);
100 |     
101 |     free(delta);
102 |     
103 | }
104 | 
105 | 
106 | void pc_decode_construction_update_Z(double *Z, double *Zvar, double v, u_int64_t *uindex){
107 |     
108 |     if(v > 1){
109 |         v = 1/v;
110 |     }
111 |     
112 |     Zvar[*uindex] += v;
113 | 
114 |     v = sqrt(v);
115 |     
116 |     Z[*uindex] += v;
117 |     
118 |     (*uindex)++;
119 | }
120 | 
121 | 
122 | void pc_decode_construction_step(double *Z, double *Zvar, Bit *u, u_int64_t n, u_int64_t step, double *val, u_int64_t *uindex){
123 |     
124 |     u_int64_t D = 1 << (n-step);
125 |     double *new_val = malloc(D*sizeof(double));
126 |     
127 |     //calcolate f
128 |     pc_decode_calc_f(new_val, val, step, n);
129 |     
130 |     if(step == n){
131 |         pc_decode_construction_update_Z(Z, Zvar, new_val[0], uindex);
132 |     }else{
133 |         pc_decode_construction_step(Z, Zvar, u, n, step+1, new_val, uindex);
134 |     }
135 |     
136 |     //calcolate f
137 |     pc_decode_calc_g(new_val, val, step, n, u, *uindex);
138 | 
139 |     if(step == n){
140 |         pc_decode_construction_update_Z(Z, Zvar, new_val[0], uindex);
141 |     }else{
142 |         pc_decode_construction_step(Z, Zvar, u, n, step+1, new_val, uindex);
143 |     }
144 |     
145 |     free(new_val);
146 |     
147 | }
148 | 
149 | 
150 | 


--------------------------------------------------------------------------------
/PolarCodes/error_rate.c:
--------------------------------------------------------------------------------
  1 | //
  2 | //  error_rate.c
  3 | //  PolarCodes
  4 | //
  5 | //  Created by Nicola De Franceschi on 27/10/13.
  6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
  7 | //
  8 | 
  9 | 
 10 | #include <stdio.h>
 11 | #include <stdlib.h>
 12 | #include <string.h>
 13 | #include <inttypes.h>
 14 | #include "error_rate.h"
 15 | #include "double_ei.h"
 16 | 
 17 | void get_error_rate_file_name(char *filename, u_int64_t n, Channel *channel, u_int64_t K) {
 18 |     sprintf(filename, "er_%" PRIu64 "_ch_%d_par_%f" "_k_%" PRIu64 ".txt", n, channel->channel_type, channel->par, K);
 19 | }
 20 | 
 21 | void get_error_rate_file_name_tmp(char *filename, u_int64_t n, Channel *channel, u_int64_t K) {
 22 |     sprintf(filename, "er_%" PRIu64 "_ch_%d_par_%f" "_k_%" PRIu64 ".tmp.txt", n, channel->channel_type, channel->par, K);
 23 | }
 24 | 
 25 | FILE *open_error_rate_file_in(const char *dir, u_int64_t n, Channel *channel, u_int64_t K) {
 26 |     char filename[1024];
 27 |     strcpy(filename, dir);
 28 |     char *name = filename + strlen(filename);
 29 |     get_error_rate_file_name(name, n, channel, K);
 30 |     return fopen(filename, "r");
 31 | }
 32 | 
 33 | FILE *open_error_rate_file_out(const char *dir, u_int64_t n, Channel *channel, u_int64_t K) {
 34 |     char filename[1024];
 35 |     strcpy(filename, dir);
 36 |     char *name = filename + strlen(filename);
 37 |     get_error_rate_file_name(name, n, channel, K);
 38 |     return fopen(filename, "w");
 39 | }
 40 | 
 41 | FILE *open_error_rate_file_out_temp(const char *dir, u_int64_t n, Channel *channel, u_int64_t K) {
 42 |     char filename[1024];
 43 |     strcpy(filename, dir);
 44 |     char *name = filename + strlen(filename);
 45 |     get_error_rate_file_name_tmp(name, n, channel, K);
 46 |     return fopen(filename, "w");
 47 | }
 48 | 
 49 | 
 50 | void get_or_create_error_rate(ErrorRate *er, const char *dir, u_int64_t n, Channel *channel, u_int64_t K) {
 51 |     er->n = n;
 52 |     er->channel.channel_type = channel->channel_type;
 53 |     er->channel.par = channel->par;
 54 |     er->K = K;
 55 | 
 56 |     FILE *in = open_error_rate_file_in(dir, n, channel, K);
 57 |     if(in){
 58 |         if(1 != fscanf(in, "%" PRIu64, &(er->total_samples)))
 59 |             exit(1);
 60 |         er->BER = double_fget(in);
 61 |         er->BER_2 = double_fget(in);
 62 |         if(1 != fscanf(in, "%" PRIu64, &(er->frame_errors)))
 63 |             exit(1);
 64 |         
 65 |         fclose(in);
 66 |         in = NULL;
 67 |     }else{
 68 |         er->total_samples = 0;
 69 |         er->BER = 0;
 70 |         er->BER_2 = 0;
 71 |         er->frame_errors = 0;
 72 |     }
 73 | }
 74 | 
 75 | void get_error_rate(ErrorRate *er, const char *dir, u_int64_t n, Channel *channel, u_int64_t K) {
 76 |     er->n = n;
 77 |     er->channel.channel_type = channel->channel_type;
 78 |     er->channel.par = channel->par;
 79 |     er->K = K;
 80 | 
 81 |     FILE *in = open_error_rate_file_in(dir, n, channel, K);
 82 |     if(in){
 83 |         if(1 != fscanf(in, "%" PRIu64, &(er->total_samples)))
 84 |             exit(1);
 85 |         er->BER = double_fget(in);
 86 |         er->BER_2 = double_fget(in);
 87 |         if(1 != fscanf(in, "%" PRIu64, &(er->frame_errors)))
 88 |             exit(1);
 89 | 
 90 |         fclose(in);
 91 |         in = NULL;
 92 |     }else{
 93 |         exit(4);
 94 |     }
 95 |     
 96 | }
 97 | 
 98 | void save_error_rate(ErrorRate *er, const char *dir) {
 99 |     FILE *out = open_error_rate_file_out_temp(dir, er->n, &(er->channel), er->K);
100 |     if(!out)
101 |         exit(1);
102 | 
103 |     fprintf(out, "%" PRIu64 "\n", er->total_samples);
104 |     double_fput(out, er->BER);
105 |     fprintf(out, " ");
106 |     double_fput(out, er->BER_2);
107 |     fprintf(out, " ");
108 |     fprintf(out, "%" PRIu64 "\n", er->frame_errors);
109 | 
110 |     fclose(out);
111 |     out = NULL;
112 |     
113 |     char old[1024];
114 |     strcpy(old, dir);
115 |     char *name = old + strlen(dir);
116 |     get_error_rate_file_name_tmp(name, er->n, &(er->channel), er->K);
117 |     
118 |     char new[1024];
119 |     strcpy(new, dir);
120 |     name = new + strlen(dir);
121 |     get_error_rate_file_name(name, er->n, &(er->channel), er->K);
122 |     
123 |     rename(old, new);
124 |     
125 | }
126 | 


--------------------------------------------------------------------------------
/PC_pc_simulate/main.c:
--------------------------------------------------------------------------------
  1 | //
  2 | //  main.c
  3 | //  pc_simulate
  4 | //
  5 | //  Created by Nicola De Franceschi on 26/10/13.
  6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
  7 | //
  8 | 
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 12 | #include <inttypes.h>
 13 | #include <sys/time.h>
 14 | #include "../PolarCodes/polar_codes.h"
 15 | #include "../PolarCodes/bhattacharyya_files.h"
 16 | #include "../PolarCodes/pc_encode.h"
 17 | #include "../PolarCodes/pc_decode.h"
 18 | #include "../PolarCodes/channels.h"
 19 | #include "../PolarCodes/error_rate.h"
 20 | 
 21 | 
 22 | #define DEFAULT_max_n_samples (1<<30)
 23 | 
 24 | 
 25 | // call with arguments: n ch_type ch_par Kmin Kdelta Kmax n_samples max_n_samples dir
 26 | // max_n_samples==-1 for default
 27 | // Kmin Kdelta Kmax are actually Kmin/N Kdelta/N Kmax/N
 28 | int main(int argc, const char * argv[])
 29 | {
 30 |     
 31 |     //random initialization
 32 |     struct timeval time;
 33 |     gettimeofday(&time,NULL);
 34 |     srand((unsigned int)(time.tv_sec + time.tv_usec));
 35 | 
 36 |     
 37 |     Channel channel;
 38 |     u_int64_t n;
 39 |     double Kmin, Kdelta, Kmax;
 40 |     u_int64_t n_samples;
 41 |     int64_t max_n_samples;
 42 |     const char *dir;
 43 |     
 44 |     if(argc != 10)
 45 |         exit(2);
 46 |     
 47 |     
 48 |     //n
 49 |     sscanf(argv[1], "%" PRIu64, &n);
 50 |     
 51 |     //ch_type
 52 |     sscanf(argv[2], "%d", &(channel.channel_type));
 53 |     
 54 |     //ch_par
 55 |     sscanf(argv[3], "%lf", &(channel.par));
 56 |     
 57 |     //Kmin Kdelta Kmax
 58 |     sscanf(argv[4], "%lf", &Kmin);
 59 |     sscanf(argv[5], "%lf", &Kdelta);
 60 |     sscanf(argv[6], "%lf", &Kmax);
 61 |     
 62 |     //n_samples
 63 |     sscanf(argv[7], "%" PRIu64, &n_samples);
 64 |     
 65 |     //max_n_samples
 66 |     sscanf(argv[8], "%" PRId64, &max_n_samples);
 67 |     if(max_n_samples == -1)
 68 |         max_n_samples=DEFAULT_max_n_samples;
 69 |     
 70 |     //dir
 71 |     dir = argv[9];
 72 |     
 73 |     
 74 |     u_int64_t N = 1 << n;
 75 |     
 76 |     Bhattacharyya b;
 77 |     get_bhattacharyya(&b, dir, n, &channel);
 78 |     
 79 |     
 80 |     u_int64_t lastK=0;
 81 |     u_int64_t numK = (u_int64_t)((Kmax-Kmin)/Kdelta)+1;
 82 |     u_int64_t realNumK=0;
 83 |     Bit **As = malloc(sizeof(Bit*)*numK);
 84 |     ErrorRate *ers = malloc(sizeof(ErrorRate)*numK);
 85 |     
 86 |     u_int64_t i;
 87 |     for(i=0;i<numK;i++){
 88 |         u_int64_t K = (u_int64_t)((Kmin+Kdelta*i) * N);
 89 |         if(K == lastK)
 90 |             continue;
 91 |         if(K > N)
 92 |             break;
 93 |         
 94 |         lastK = K;
 95 |         Bit *A = malloc(sizeof(Bit)*N);
 96 |         get_frozen_bits(A, K, &b);
 97 |         As[realNumK]=A;
 98 |         
 99 |         get_or_create_error_rate(&ers[realNumK], dir, n, &channel, K);
100 | 
101 |         realNumK++;
102 |     }
103 |     
104 |     numK=realNumK;
105 |     
106 |     Bit *u = malloc(sizeof(Bit)*N);
107 |     Bit *x = malloc(sizeof(Bit)*N);
108 |     
109 |     while (1) {
110 |         
111 |         u_int64_t num_done = 0;
112 |         
113 |         u_int64_t k;
114 |         for(k=0; k<numK; k++){
115 |             
116 |             if(ers[k].total_samples > max_n_samples){
117 |                 num_done++;
118 |                 continue;
119 |             }
120 |             
121 |             Bit *A = As[k];
122 |             for(i=0; i < n_samples; i++){
123 |                 
124 |                 random_bits_f(u, A, N);
125 |                 pc_encode(x, u, n);
126 |                 apply_channel(x, x, &channel, n);
127 |                 pc_decode(x, x, &channel, A, n);
128 |                 
129 |                 u_int64_t bit_errors = 0;
130 |                 u_int64_t j;
131 |                 for(j=0; j < N; j++){
132 |                     if(u[j] != x[j])
133 |                         bit_errors++;
134 |                 }
135 |                 
136 |                 double ber = (double)bit_errors / (double)N;
137 |                 
138 |                 ers[k].total_samples++;
139 |                 ers[k].BER += ber;
140 |                 ers[k].BER_2 += ber*ber;
141 |                 if(bit_errors > 0)
142 |                     ers[k].frame_errors++;
143 |                 
144 |             }
145 |             
146 |             save_error_rate(&ers[k], dir);
147 |             printf("K = %lld, total_samples = %lld\n", ers[k].K, ers[k].total_samples);
148 |             
149 |         }
150 |         
151 |         if(num_done == numK)
152 |             break;
153 |         
154 |     }
155 |     
156 |     return 0;
157 | }
158 | 
159 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | #########################
  2 | # .gitignore file for Xcode4 / OS X Source projects
  3 | #
  4 | # Version 2.1
  5 | # For latest version, see: http://stackoverflow.com/questions/49478/git-ignore-file-for-xcode-projects
  6 | #
  7 | # 2013 updates:
  8 | # - fixed the broken "save personal Schemes"
  9 | # - added line-by-line explanations for EVERYTHING (some were missing)
 10 | #
 11 | # NB: if you are storing "built" products, this WILL NOT WORK,
 12 | # and you should use a different .gitignore (or none at all)
 13 | # This file is for SOURCE projects, where there are many extra
 14 | # files that we want to exclude
 15 | #
 16 | #########################
 17 | 
 18 | ####
 19 | # make generated files
 20 | 
 21 | .o
 22 | 
 23 | 
 24 | ####
 25 | # Xcode 5 -  Source Control files
 26 | #
 27 | # Xcode 5 introduced a new file type .xccheckout. This files contains VCS metadata
 28 | # and should therefore not be checked into the VCS.
 29 | 
 30 | *.xccheckout
 31 | 
 32 | #####
 33 | # OS X temporary files that should never be committed
 34 | #
 35 | # c.f. http://www.westwind.com/reference/os-x/invisibles.html
 36 | 
 37 | .DS_Store
 38 | 
 39 | # c.f. http://www.westwind.com/reference/os-x/invisibles.html
 40 | 
 41 | .Trashes
 42 | 
 43 | # c.f. http://www.westwind.com/reference/os-x/invisibles.html
 44 | 
 45 | *.swp
 46 | 
 47 | # *.lock - this is used and abused by many editors for many different things.
 48 | #    For the main ones I use (e.g. Eclipse), it should be excluded 
 49 | #    from source-control, but YMMV
 50 | 
 51 | *.lock
 52 | 
 53 | #
 54 | # profile - REMOVED temporarily (on double-checking, this seems incorrect; I can't find it in OS X docs?)
 55 | #profile
 56 | 
 57 | 
 58 | ####
 59 | # Xcode temporary files that should never be committed
 60 | # 
 61 | # NB: NIB/XIB files still exist even on Storyboard projects, so we want this...
 62 | 
 63 | *~.nib
 64 | 
 65 | 
 66 | ####
 67 | # Xcode build files -
 68 | #
 69 | # NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "DerivedData"
 70 | 
 71 | DerivedData/
 72 | 
 73 | # NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "build"
 74 | 
 75 | build/
 76 | 
 77 | 
 78 | #####
 79 | # Xcode private settings (window sizes, bookmarks, breakpoints, custom executables, smart groups)
 80 | #
 81 | # This is complicated:
 82 | #
 83 | # SOMETIMES you need to put this file in version control.
 84 | # Apple designed it poorly - if you use "custom executables", they are
 85 | #  saved in this file.
 86 | # 99% of projects do NOT use those, so they do NOT want to version control this file.
 87 | #  ..but if you're in the 1%, comment out the line "*.pbxuser"
 88 | 
 89 | # .pbxuser: http://lists.apple.com/archives/xcode-users/2004/Jan/msg00193.html
 90 | 
 91 | *.pbxuser
 92 | 
 93 | # .mode1v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
 94 | 
 95 | *.mode1v3
 96 | 
 97 | # .mode2v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
 98 | 
 99 | *.mode2v3
100 | 
101 | # .perspectivev3: http://stackoverflow.com/questions/5223297/xcode-projects-what-is-a-perspectivev3-file
102 | 
103 | *.perspectivev3
104 | 
105 | #    NB: also, whitelist the default ones, some projects need to use these
106 | !default.pbxuser
107 | !default.mode1v3
108 | !default.mode2v3
109 | !default.perspectivev3
110 | 
111 | 
112 | ####
113 | # Xcode 4 - semi-personal settings
114 | #
115 | #
116 | # OPTION 1: ---------------------------------
117 | #     throw away ALL personal settings (including custom schemes!
118 | #     - unless they are "shared")
119 | #
120 | # NB: this is exclusive with OPTION 2 below
121 | xcuserdata
122 | 
123 | # OPTION 2: ---------------------------------
124 | #     get rid of ALL personal settings, but KEEP SOME OF THEM
125 | #     - NB: you must manually uncomment the bits you want to keep
126 | #
127 | # NB: this *requires* git v1.8.2 or above; you may need to upgrade to latest OS X,
128 | #    or manually install git over the top of the OS X version
129 | # NB: this is exclusive with OPTION 1 above
130 | #
131 | #xcuserdata/**/*
132 | 
133 | #     (requires option 2 above): Personal Schemes
134 | #
135 | #!xcuserdata/**/xcschemes/*
136 | 
137 | ####
138 | # XCode 4 workspaces - more detailed
139 | #
140 | # Workspaces are important! They are a core feature of Xcode - don't exclude them :)
141 | #
142 | # Workspace layout is quite spammy. For reference:
143 | #
144 | # /(root)/
145 | #   /(project-name).xcodeproj/
146 | #     project.pbxproj
147 | #     /project.xcworkspace/
148 | #       contents.xcworkspacedata
149 | #       /xcuserdata/
150 | #         /(your name)/xcuserdatad/
151 | #           UserInterfaceState.xcuserstate
152 | #     /xcsshareddata/
153 | #       /xcschemes/
154 | #         (shared scheme name).xcscheme
155 | #     /xcuserdata/
156 | #       /(your name)/xcuserdatad/
157 | #         (private scheme).xcscheme
158 | #         xcschememanagement.plist
159 | #
160 | #
161 | 
162 | ####
163 | # Xcode 4 - Deprecated classes
164 | #
165 | # Allegedly, if you manually "deprecate" your classes, they get moved here.
166 | #
167 | # We're using source-control, so this is a "feature" that we do not want!
168 | 
169 | *.moved-aside
170 | 
171 | ####
172 | # UNKNOWN: recommended by others, but I can't discover what these files are
173 | #
174 | # ...none. Everything is now explained.
175 | 


--------------------------------------------------------------------------------
/PolarCodes/bhattacharyya_files.c:
--------------------------------------------------------------------------------
  1 | //
  2 | //  bhattacharyya_files.c
  3 | //  PolarCodes
  4 | //
  5 | //  Created by Nicola De Franceschi on 25/10/13.
  6 | //  Copyright (c) 2013 Nicola De Franceschi. All rights reserved.
  7 | //
  8 | 
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 12 | #include <inttypes.h>
 13 | #include "channels.h"
 14 | #include "bhattacharyya_files.h"
 15 | #include "double_ei.h"
 16 | 
 17 | void get_bhattacharyya_file_name(char *filename, u_int64_t n, Channel *channel) {
 18 |     sprintf(filename, "bh_%" PRIu64 "_ch_%d_par_%f" ".txt", n, channel->channel_type, channel->par);
 19 | }
 20 | 
 21 | void get_bhattacharyya_file_name_tmp(char *filename, u_int64_t n, Channel *channel) {
 22 |     sprintf(filename, "bh_%" PRIu64 "_ch_%d_par_%f" ".tmp.txt", n, channel->channel_type, channel->par);
 23 | }
 24 | 
 25 | FILE *open_bhattacharyya_file_in(const char *dir, u_int64_t n, Channel *channel) {
 26 |     char filename[1024];
 27 |     strcpy(filename, dir);
 28 |     char *name = filename + strlen(filename);
 29 |     get_bhattacharyya_file_name(name, n, channel);
 30 |     return fopen(filename, "r");
 31 | }
 32 | 
 33 | FILE *open_bhattacharyya_file_out(const char *dir, u_int64_t n, Channel *channel) {
 34 |     char filename[1024];
 35 |     strcpy(filename, dir);
 36 |     char *name = filename + strlen(filename);
 37 |     get_bhattacharyya_file_name(name, n, channel);
 38 |     return fopen(filename, "w");
 39 | }
 40 | 
 41 | FILE *open_bhattacharyya_file_out_temp(const char *dir, u_int64_t n, Channel *channel) {
 42 |     char filename[1024];
 43 |     strcpy(filename, dir);
 44 |     char *name = filename + strlen(filename);
 45 |     get_bhattacharyya_file_name_tmp(name, n, channel);
 46 |     return fopen(filename, "w");
 47 | }
 48 | 
 49 | void get_or_create_bhattacharyya(Bhattacharyya *b, const char *dir, u_int64_t n, Channel *channel) {
 50 |     u_int64_t N = 1<<n;
 51 |     
 52 |     b->n = n;
 53 |     b->channel.channel_type = channel->channel_type;
 54 |     b->channel.par = channel->par;
 55 |     b->Z = malloc(sizeof(double)*N);
 56 |     b->Zvar = malloc(sizeof(double)*N);
 57 |     b->total_samples = 0;
 58 |     
 59 |     u_int64_t i;
 60 |     FILE *in = open_bhattacharyya_file_in(dir, n, channel);
 61 |     if(in){
 62 |         if(1 != fscanf(in, "%" PRIu64, &(b->total_samples)))
 63 |             exit(1);
 64 |         for(i = 0; i < N; i++){
 65 |             b->Z[i] = double_fget(in);
 66 |             b->Zvar[i] = double_fget(in);
 67 |         }
 68 |         fclose(in);
 69 |         in = NULL;
 70 |     }else{
 71 |         memset(b->Z, 0, sizeof(double)*N);
 72 |         memset(b->Zvar, 0, sizeof(double)*N);
 73 |     }
 74 | 
 75 | }
 76 | 
 77 | void get_bhattacharyya(Bhattacharyya *b, const char *dir, u_int64_t n, Channel *channel) {
 78 |     u_int64_t N = 1<<n;
 79 | 
 80 |     b->n = n;
 81 |     b->channel.channel_type = channel->channel_type;
 82 |     b->channel.par = channel->par;
 83 |     b->Z = malloc(sizeof(double)*N);
 84 |     b->Zvar = malloc(sizeof(double)*N);
 85 |     b->total_samples = 0;
 86 |     
 87 |     u_int64_t i;
 88 |     FILE *in = open_bhattacharyya_file_in(dir, n, channel);
 89 |     if(in){
 90 |         if(1 != fscanf(in, "%" PRIu64, &(b->total_samples)))
 91 |             exit(1);
 92 |         for(i = 0; i < N; i++){
 93 |             b->Z[i] = double_fget(in);
 94 |             b->Zvar[i] = double_fget(in);
 95 |         }
 96 |         fclose(in);
 97 |         in = NULL;
 98 |     }else{
 99 |         exit(4);
100 |     }
101 | 
102 | }
103 | 
104 | void save_bhattacharyya(Bhattacharyya *b, const char *dir) {
105 |     u_int64_t N = 1 << b->n;
106 |     u_int64_t i;
107 |     FILE *out = open_bhattacharyya_file_out_temp(dir, b->n, &(b->channel));
108 |     if(!out)
109 |         exit(1);
110 |     fprintf(out, "%" PRIu64 "\n", b->total_samples);
111 |     for(i = 0; i < N; i++){
112 |         double_fput(out, b->Z[i]);
113 |         fprintf(out, " ");
114 |         double_fput(out, b->Zvar[i]);
115 |         fprintf(out, "\n");
116 |     }
117 |     fclose(out);
118 |     out = NULL;
119 |     
120 |     char old[1024];
121 |     strcpy(old, dir);
122 |     char *name = old + strlen(dir);
123 |     get_bhattacharyya_file_name_tmp(name, b->n, &(b->channel));
124 |     
125 |     char new[1024];
126 |     strcpy(new, dir);
127 |     name = new + strlen(dir);
128 |     get_bhattacharyya_file_name(name, b->n, &(b->channel));
129 |     
130 |     rename(old, new);
131 | 
132 | }
133 | 
134 | struct frozen_bits_index_struct {
135 |     u_int64_t index;
136 |     Bhattacharyya *b;
137 | };
138 | 
139 | int frozen_bits_sort_cmp(const void *x, const void *y)
140 | {
141 |     struct frozen_bits_index_struct *xx = (struct frozen_bits_index_struct*)x;
142 |     struct frozen_bits_index_struct *yy = (struct frozen_bits_index_struct*)y;
143 |     Bhattacharyya *b = xx->b;
144 |     if (b->Z[xx->index] < b->Z[yy->index]) return -1;
145 |     if (b->Z[xx->index] > b->Z[yy->index]) return 1;
146 |     return 0;
147 | }
148 | 
149 | void get_frozen_bits(Bit *bits, u_int64_t K, Bhattacharyya *b) {
150 |     u_int64_t N = 1 << b->n;
151 |     struct frozen_bits_index_struct *indexes = (struct frozen_bits_index_struct*)malloc(sizeof(struct frozen_bits_index_struct)*N);
152 |     u_int64_t i;
153 |     for(i=0;i<N;i++){
154 |         indexes[i].index = i;
155 |         indexes[i].b = b;
156 |     }
157 |     
158 |     qsort(indexes, N, sizeof(struct frozen_bits_index_struct), &frozen_bits_sort_cmp);
159 |         
160 |     memset(bits, 0, N);
161 |     for(i=0;i<K;i++){
162 |         u_int64_t index = indexes[i].index;
163 |         bits[index] = 1;
164 |     }
165 |     
166 | }
167 | 
168 | 


--------------------------------------------------------------------------------
/PolarCodes.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 46;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		B31E0A2E181CBCF100E941E5 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = B31E0A2D181CBCF100E941E5 /* main.c */; };
 11 | 		B31E0A30181CBCF100E941E5 /* pc_simulate.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = B31E0A2F181CBCF100E941E5 /* pc_simulate.1 */; };
 12 | 		B31E0A34181CBDDA00E941E5 /* channels.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195D181B0AD900055AD4 /* channels.c */; };
 13 | 		B31E0A36181CBDDA00E941E5 /* double_ei.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195F181B0AD900055AD4 /* double_ei.c */; };
 14 | 		B31E0A38181CBDDA00E941E5 /* pc_construction.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71961181B0AD900055AD4 /* pc_construction.c */; };
 15 | 		B31E0A3A181CBDDA00E941E5 /* pc_decode_internal.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71963181B0AD900055AD4 /* pc_decode_internal.c */; };
 16 | 		B31E0A3C181CBDDA00E941E5 /* pc_decode.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71965181B0AD900055AD4 /* pc_decode.c */; };
 17 | 		B31E0A3E181CBDDA00E941E5 /* pc_encode.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71967181B0AD900055AD4 /* pc_encode.c */; };
 18 | 		B31E0A40181CBDDA00E941E5 /* polar_codes.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71969181B0AD900055AD4 /* polar_codes.c */; };
 19 | 		B31E0A42181CBDDA00E941E5 /* bhattacharyya_files.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B719AC181B15AE00055AD4 /* bhattacharyya_files.c */; };
 20 | 		B36B90AE181CCA41008E21AB /* error_rate.c in Sources */ = {isa = PBXBuildFile; fileRef = B36B90AD181CCA41008E21AB /* error_rate.c */; };
 21 | 		B36B90AF181CCA41008E21AB /* error_rate.c in Sources */ = {isa = PBXBuildFile; fileRef = B36B90AD181CCA41008E21AB /* error_rate.c */; };
 22 | 		B3B7197B181B0C5500055AD4 /* Test_double_ei.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = B3B7197A181B0C5500055AD4 /* Test_double_ei.1 */; };
 23 | 		B3B71981181B0CAB00055AD4 /* double_ei.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195F181B0AD900055AD4 /* double_ei.c */; };
 24 | 		B3B71995181B0CFC00055AD4 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71994181B0CFC00055AD4 /* main.c */; };
 25 | 		B3B71997181B0CFC00055AD4 /* pc_construction.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = B3B71996181B0CFC00055AD4 /* pc_construction.1 */; };
 26 | 		B3B7199C181B0D3100055AD4 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7199B181B0D3100055AD4 /* main.c */; };
 27 | 		B3B7199D181B127A00055AD4 /* channels.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195D181B0AD900055AD4 /* channels.c */; };
 28 | 		B3B7199F181B127A00055AD4 /* double_ei.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195F181B0AD900055AD4 /* double_ei.c */; };
 29 | 		B3B719A1181B127A00055AD4 /* pc_construction.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71961181B0AD900055AD4 /* pc_construction.c */; };
 30 | 		B3B719A3181B127A00055AD4 /* pc_decode_internal.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71963181B0AD900055AD4 /* pc_decode_internal.c */; };
 31 | 		B3B719A5181B127A00055AD4 /* pc_decode.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71965181B0AD900055AD4 /* pc_decode.c */; };
 32 | 		B3B719A7181B127A00055AD4 /* pc_encode.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71967181B0AD900055AD4 /* pc_encode.c */; };
 33 | 		B3B719A9181B127A00055AD4 /* polar_codes.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71969181B0AD900055AD4 /* polar_codes.c */; };
 34 | 		B3B719AD181B15AE00055AD4 /* bhattacharyya_files.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B719AC181B15AE00055AD4 /* bhattacharyya_files.c */; };
 35 | 		B3E4D4331843CE3700EAA309 /* main.c in Sources */ = {isa = PBXBuildFile; fileRef = B3E4D4321843CE3700EAA309 /* main.c */; };
 36 | 		B3E4D4351843CE3700EAA309 /* Test_bec.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = B3E4D4341843CE3700EAA309 /* Test_bec.1 */; };
 37 | 		B3E4D4391843CE7200EAA309 /* channels.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195D181B0AD900055AD4 /* channels.c */; };
 38 | 		B3E4D43A1843CE7200EAA309 /* channels.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195E181B0AD900055AD4 /* channels.h */; };
 39 | 		B3E4D43B1843CE7200EAA309 /* double_ei.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B7195F181B0AD900055AD4 /* double_ei.c */; };
 40 | 		B3E4D43C1843CE7200EAA309 /* double_ei.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B71960181B0AD900055AD4 /* double_ei.h */; };
 41 | 		B3E4D43D1843CE7200EAA309 /* pc_construction.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71961181B0AD900055AD4 /* pc_construction.c */; };
 42 | 		B3E4D43E1843CE7200EAA309 /* pc_construction.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B71962181B0AD900055AD4 /* pc_construction.h */; };
 43 | 		B3E4D43F1843CE7200EAA309 /* pc_decode_internal.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71963181B0AD900055AD4 /* pc_decode_internal.c */; };
 44 | 		B3E4D4401843CE7200EAA309 /* pc_decode_internal.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B71964181B0AD900055AD4 /* pc_decode_internal.h */; };
 45 | 		B3E4D4411843CE7200EAA309 /* pc_decode.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71965181B0AD900055AD4 /* pc_decode.c */; };
 46 | 		B3E4D4421843CE7200EAA309 /* pc_decode.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B71966181B0AD900055AD4 /* pc_decode.h */; };
 47 | 		B3E4D4431843CE7200EAA309 /* pc_encode.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71967181B0AD900055AD4 /* pc_encode.c */; };
 48 | 		B3E4D4441843CE7200EAA309 /* pc_encode.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B71968181B0AD900055AD4 /* pc_encode.h */; };
 49 | 		B3E4D4451843CE7200EAA309 /* polar_codes.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B71969181B0AD900055AD4 /* polar_codes.c */; };
 50 | 		B3E4D4461843CE7200EAA309 /* polar_codes.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B7196A181B0AD900055AD4 /* polar_codes.h */; };
 51 | 		B3E4D4471843CE7200EAA309 /* bhattacharyya_files.c in Sources */ = {isa = PBXBuildFile; fileRef = B3B719AC181B15AE00055AD4 /* bhattacharyya_files.c */; };
 52 | 		B3E4D4481843CE7200EAA309 /* bhattacharyya_files.h in Sources */ = {isa = PBXBuildFile; fileRef = B3B719AB181B159B00055AD4 /* bhattacharyya_files.h */; };
 53 | 		B3E4D4491843CE7200EAA309 /* error_rate.h in Sources */ = {isa = PBXBuildFile; fileRef = B36B90AC181CCA2E008E21AB /* error_rate.h */; };
 54 | 		B3E4D44A1843CE7200EAA309 /* error_rate.c in Sources */ = {isa = PBXBuildFile; fileRef = B36B90AD181CCA41008E21AB /* error_rate.c */; };
 55 | /* End PBXBuildFile section */
 56 | 
 57 | /* Begin PBXCopyFilesBuildPhase section */
 58 | 		B31E0A29181CBCF100E941E5 /* CopyFiles */ = {
 59 | 			isa = PBXCopyFilesBuildPhase;
 60 | 			buildActionMask = 2147483647;
 61 | 			dstPath = /usr/share/man/man1/;
 62 | 			dstSubfolderSpec = 0;
 63 | 			files = (
 64 | 				B31E0A30181CBCF100E941E5 /* pc_simulate.1 in CopyFiles */,
 65 | 			);
 66 | 			runOnlyForDeploymentPostprocessing = 1;
 67 | 		};
 68 | 		B3B71974181B0C5500055AD4 /* CopyFiles */ = {
 69 | 			isa = PBXCopyFilesBuildPhase;
 70 | 			buildActionMask = 2147483647;
 71 | 			dstPath = /usr/share/man/man1/;
 72 | 			dstSubfolderSpec = 0;
 73 | 			files = (
 74 | 				B3B7197B181B0C5500055AD4 /* Test_double_ei.1 in CopyFiles */,
 75 | 			);
 76 | 			runOnlyForDeploymentPostprocessing = 1;
 77 | 		};
 78 | 		B3B71990181B0CFC00055AD4 /* CopyFiles */ = {
 79 | 			isa = PBXCopyFilesBuildPhase;
 80 | 			buildActionMask = 2147483647;
 81 | 			dstPath = /usr/share/man/man1/;
 82 | 			dstSubfolderSpec = 0;
 83 | 			files = (
 84 | 				B3B71997181B0CFC00055AD4 /* pc_construction.1 in CopyFiles */,
 85 | 			);
 86 | 			runOnlyForDeploymentPostprocessing = 1;
 87 | 		};
 88 | 		B3E4D42E1843CE3700EAA309 /* CopyFiles */ = {
 89 | 			isa = PBXCopyFilesBuildPhase;
 90 | 			buildActionMask = 2147483647;
 91 | 			dstPath = /usr/share/man/man1/;
 92 | 			dstSubfolderSpec = 0;
 93 | 			files = (
 94 | 				B3E4D4351843CE3700EAA309 /* Test_bec.1 in CopyFiles */,
 95 | 			);
 96 | 			runOnlyForDeploymentPostprocessing = 1;
 97 | 		};
 98 | /* End PBXCopyFilesBuildPhase section */
 99 | 
100 | /* Begin PBXFileReference section */
101 | 		B31E0A21181CBADA00E941E5 /* .gitignore */ = {isa = PBXFileReference; lastKnownFileType = text; path = .gitignore; sourceTree = "<group>"; };
102 | 		B31E0A22181CBB5900E941E5 /* batch_pc_construction.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = batch_pc_construction.sh; sourceTree = "<group>"; };
103 | 		B31E0A23181CBB5900E941E5 /* Makefile */ = {isa = PBXFileReference; explicitFileType = sourcecode.make; path = Makefile; sourceTree = "<group>"; };
104 | 		B31E0A24181CBB5900E941E5 /* pc_construction_launcher.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = pc_construction_launcher.sh; sourceTree = "<group>"; };
105 | 		B31E0A25181CBB5900E941E5 /* qbatch_pc_construction.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = qbatch_pc_construction.sh; sourceTree = "<group>"; };
106 | 		B31E0A26181CBB5900E941E5 /* test.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = test.sh; sourceTree = "<group>"; };
107 | 		B31E0A2B181CBCF100E941E5 /* pc_simulate */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = pc_simulate; sourceTree = BUILT_PRODUCTS_DIR; };
108 | 		B31E0A2D181CBCF100E941E5 /* main.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = main.c; sourceTree = "<group>"; };
109 | 		B31E0A2F181CBCF100E941E5 /* pc_simulate.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = pc_simulate.1; sourceTree = "<group>"; };
110 | 		B36B90AC181CCA2E008E21AB /* error_rate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = error_rate.h; sourceTree = "<group>"; };
111 | 		B36B90AD181CCA41008E21AB /* error_rate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = error_rate.c; sourceTree = "<group>"; };
112 | 		B3B458DB181D686A008FB52F /* pc_simulate_launcher.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = pc_simulate_launcher.sh; sourceTree = "<group>"; };
113 | 		B3B458DC181D686A008FB52F /* qbatch_pc_simulate.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = qbatch_pc_simulate.sh; sourceTree = "<group>"; };
114 | 		B3B7195D181B0AD900055AD4 /* channels.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = channels.c; sourceTree = "<group>"; };
115 | 		B3B7195E181B0AD900055AD4 /* channels.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = channels.h; sourceTree = "<group>"; };
116 | 		B3B7195F181B0AD900055AD4 /* double_ei.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = double_ei.c; sourceTree = "<group>"; };
117 | 		B3B71960181B0AD900055AD4 /* double_ei.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = double_ei.h; sourceTree = "<group>"; };
118 | 		B3B71961181B0AD900055AD4 /* pc_construction.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = pc_construction.c; sourceTree = "<group>"; };
119 | 		B3B71962181B0AD900055AD4 /* pc_construction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pc_construction.h; sourceTree = "<group>"; };
120 | 		B3B71963181B0AD900055AD4 /* pc_decode_internal.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = pc_decode_internal.c; sourceTree = "<group>"; };
121 | 		B3B71964181B0AD900055AD4 /* pc_decode_internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pc_decode_internal.h; sourceTree = "<group>"; };
122 | 		B3B71965181B0AD900055AD4 /* pc_decode.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = pc_decode.c; sourceTree = "<group>"; };
123 | 		B3B71966181B0AD900055AD4 /* pc_decode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pc_decode.h; sourceTree = "<group>"; };
124 | 		B3B71967181B0AD900055AD4 /* pc_encode.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = pc_encode.c; sourceTree = "<group>"; };
125 | 		B3B71968181B0AD900055AD4 /* pc_encode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pc_encode.h; sourceTree = "<group>"; };
126 | 		B3B71969181B0AD900055AD4 /* polar_codes.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = polar_codes.c; sourceTree = "<group>"; };
127 | 		B3B7196A181B0AD900055AD4 /* polar_codes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = polar_codes.h; sourceTree = "<group>"; };
128 | 		B3B71976181B0C5500055AD4 /* Test_double_ei */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = Test_double_ei; sourceTree = BUILT_PRODUCTS_DIR; };
129 | 		B3B7197A181B0C5500055AD4 /* Test_double_ei.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = Test_double_ei.1; sourceTree = "<group>"; };
130 | 		B3B71992181B0CFC00055AD4 /* pc_construction */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = pc_construction; sourceTree = BUILT_PRODUCTS_DIR; };
131 | 		B3B71994181B0CFC00055AD4 /* main.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = main.c; sourceTree = "<group>"; };
132 | 		B3B71996181B0CFC00055AD4 /* pc_construction.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = pc_construction.1; sourceTree = "<group>"; };
133 | 		B3B7199B181B0D3100055AD4 /* main.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = main.c; sourceTree = "<group>"; };
134 | 		B3B719AB181B159B00055AD4 /* bhattacharyya_files.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bhattacharyya_files.h; sourceTree = "<group>"; };
135 | 		B3B719AC181B15AE00055AD4 /* bhattacharyya_files.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = bhattacharyya_files.c; sourceTree = "<group>"; };
136 | 		B3E4D4301843CE3700EAA309 /* Test_bec */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = Test_bec; sourceTree = BUILT_PRODUCTS_DIR; };
137 | 		B3E4D4321843CE3700EAA309 /* main.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = main.c; sourceTree = "<group>"; };
138 | 		B3E4D4341843CE3700EAA309 /* Test_bec.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = Test_bec.1; sourceTree = "<group>"; };
139 | 		B3E4D51D18500DAA00EAA309 /* get_bhattacharyya.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = get_bhattacharyya.m; sourceTree = "<group>"; };
140 | 		B3E4D51E18500DAA00EAA309 /* get_error_rate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = get_error_rate.m; sourceTree = "<group>"; };
141 | 		B3E4D51F18500DAA00EAA309 /* mex_pc_decode.mexmaci64 */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.bundle"; path = mex_pc_decode.mexmaci64; sourceTree = "<group>"; };
142 | 		B3E4D52018500DAA00EAA309 /* mex_pc_encode.mexmaci64 */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.bundle"; path = mex_pc_encode.mexmaci64; sourceTree = "<group>"; };
143 | 		B3E4D52118500DAA00EAA309 /* pc_compile.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = pc_compile.m; sourceTree = "<group>"; };
144 | 		B3E4D52218500DAA00EAA309 /* pc_decode.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = pc_decode.m; sourceTree = "<group>"; };
145 | 		B3E4D52318500DAA00EAA309 /* pc_encode.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = pc_encode.m; sourceTree = "<group>"; };
146 | /* End PBXFileReference section */
147 | 
148 | /* Begin PBXFrameworksBuildPhase section */
149 | 		B31E0A28181CBCF100E941E5 /* Frameworks */ = {
150 | 			isa = PBXFrameworksBuildPhase;
151 | 			buildActionMask = 2147483647;
152 | 			files = (
153 | 			);
154 | 			runOnlyForDeploymentPostprocessing = 0;
155 | 		};
156 | 		B3B71973181B0C5500055AD4 /* Frameworks */ = {
157 | 			isa = PBXFrameworksBuildPhase;
158 | 			buildActionMask = 2147483647;
159 | 			files = (
160 | 			);
161 | 			runOnlyForDeploymentPostprocessing = 0;
162 | 		};
163 | 		B3B7198F181B0CFC00055AD4 /* Frameworks */ = {
164 | 			isa = PBXFrameworksBuildPhase;
165 | 			buildActionMask = 2147483647;
166 | 			files = (
167 | 			);
168 | 			runOnlyForDeploymentPostprocessing = 0;
169 | 		};
170 | 		B3E4D42D1843CE3700EAA309 /* Frameworks */ = {
171 | 			isa = PBXFrameworksBuildPhase;
172 | 			buildActionMask = 2147483647;
173 | 			files = (
174 | 			);
175 | 			runOnlyForDeploymentPostprocessing = 0;
176 | 		};
177 | /* End PBXFrameworksBuildPhase section */
178 | 
179 | /* Begin PBXGroup section */
180 | 		B31E0A2C181CBCF100E941E5 /* PC_pc_simulate */ = {
181 | 			isa = PBXGroup;
182 | 			children = (
183 | 				B31E0A2D181CBCF100E941E5 /* main.c */,
184 | 				B31E0A2F181CBCF100E941E5 /* pc_simulate.1 */,
185 | 			);
186 | 			path = PC_pc_simulate;
187 | 			sourceTree = "<group>";
188 | 		};
189 | 		B3B71933181B092300055AD4 = {
190 | 			isa = PBXGroup;
191 | 			children = (
192 | 				B31E0A22181CBB5900E941E5 /* batch_pc_construction.sh */,
193 | 				B31E0A24181CBB5900E941E5 /* pc_construction_launcher.sh */,
194 | 				B31E0A25181CBB5900E941E5 /* qbatch_pc_construction.sh */,
195 | 				B3B458DB181D686A008FB52F /* pc_simulate_launcher.sh */,
196 | 				B3B458DC181D686A008FB52F /* qbatch_pc_simulate.sh */,
197 | 				B31E0A26181CBB5900E941E5 /* test.sh */,
198 | 				B31E0A23181CBB5900E941E5 /* Makefile */,
199 | 				B31E0A21181CBADA00E941E5 /* .gitignore */,
200 | 				B3E4D51C18500DAA00EAA309 /* MATLAB */,
201 | 				B3B7193E181B092300055AD4 /* PolarCodes */,
202 | 				B3B71977181B0C5500055AD4 /* PCTest_double_ei */,
203 | 				B3B71993181B0CFC00055AD4 /* PC_pc_construction */,
204 | 				B31E0A2C181CBCF100E941E5 /* PC_pc_simulate */,
205 | 				B3E4D4311843CE3700EAA309 /* PCTest_bec */,
206 | 				B3B7193D181B092300055AD4 /* Products */,
207 | 			);
208 | 			sourceTree = "<group>";
209 | 		};
210 | 		B3B7193D181B092300055AD4 /* Products */ = {
211 | 			isa = PBXGroup;
212 | 			children = (
213 | 				B3B71976181B0C5500055AD4 /* Test_double_ei */,
214 | 				B3B71992181B0CFC00055AD4 /* pc_construction */,
215 | 				B31E0A2B181CBCF100E941E5 /* pc_simulate */,
216 | 				B3E4D4301843CE3700EAA309 /* Test_bec */,
217 | 			);
218 | 			name = Products;
219 | 			sourceTree = "<group>";
220 | 		};
221 | 		B3B7193E181B092300055AD4 /* PolarCodes */ = {
222 | 			isa = PBXGroup;
223 | 			children = (
224 | 				B3B7195D181B0AD900055AD4 /* channels.c */,
225 | 				B3B7195E181B0AD900055AD4 /* channels.h */,
226 | 				B3B7195F181B0AD900055AD4 /* double_ei.c */,
227 | 				B3B71960181B0AD900055AD4 /* double_ei.h */,
228 | 				B3B71961181B0AD900055AD4 /* pc_construction.c */,
229 | 				B3B71962181B0AD900055AD4 /* pc_construction.h */,
230 | 				B3B71963181B0AD900055AD4 /* pc_decode_internal.c */,
231 | 				B3B71964181B0AD900055AD4 /* pc_decode_internal.h */,
232 | 				B3B71965181B0AD900055AD4 /* pc_decode.c */,
233 | 				B3B71966181B0AD900055AD4 /* pc_decode.h */,
234 | 				B3B71967181B0AD900055AD4 /* pc_encode.c */,
235 | 				B3B71968181B0AD900055AD4 /* pc_encode.h */,
236 | 				B3B71969181B0AD900055AD4 /* polar_codes.c */,
237 | 				B3B7196A181B0AD900055AD4 /* polar_codes.h */,
238 | 				B3B719AC181B15AE00055AD4 /* bhattacharyya_files.c */,
239 | 				B3B719AB181B159B00055AD4 /* bhattacharyya_files.h */,
240 | 				B36B90AC181CCA2E008E21AB /* error_rate.h */,
241 | 				B36B90AD181CCA41008E21AB /* error_rate.c */,
242 | 			);
243 | 			path = PolarCodes;
244 | 			sourceTree = "<group>";
245 | 		};
246 | 		B3B71977181B0C5500055AD4 /* PCTest_double_ei */ = {
247 | 			isa = PBXGroup;
248 | 			children = (
249 | 				B3B7199B181B0D3100055AD4 /* main.c */,
250 | 				B3B7197A181B0C5500055AD4 /* Test_double_ei.1 */,
251 | 			);
252 | 			path = PCTest_double_ei;
253 | 			sourceTree = "<group>";
254 | 		};
255 | 		B3B71993181B0CFC00055AD4 /* PC_pc_construction */ = {
256 | 			isa = PBXGroup;
257 | 			children = (
258 | 				B3B71994181B0CFC00055AD4 /* main.c */,
259 | 				B3B71996181B0CFC00055AD4 /* pc_construction.1 */,
260 | 			);
261 | 			path = PC_pc_construction;
262 | 			sourceTree = "<group>";
263 | 		};
264 | 		B3E4D4311843CE3700EAA309 /* PCTest_bec */ = {
265 | 			isa = PBXGroup;
266 | 			children = (
267 | 				B3E4D4321843CE3700EAA309 /* main.c */,
268 | 				B3E4D4341843CE3700EAA309 /* Test_bec.1 */,
269 | 			);
270 | 			path = PCTest_bec;
271 | 			sourceTree = "<group>";
272 | 		};
273 | 		B3E4D51C18500DAA00EAA309 /* MATLAB */ = {
274 | 			isa = PBXGroup;
275 | 			children = (
276 | 				B3E4D51D18500DAA00EAA309 /* get_bhattacharyya.m */,
277 | 				B3E4D51E18500DAA00EAA309 /* get_error_rate.m */,
278 | 				B3E4D51F18500DAA00EAA309 /* mex_pc_decode.mexmaci64 */,
279 | 				B3E4D52018500DAA00EAA309 /* mex_pc_encode.mexmaci64 */,
280 | 				B3E4D52118500DAA00EAA309 /* pc_compile.m */,
281 | 				B3E4D52218500DAA00EAA309 /* pc_decode.m */,
282 | 				B3E4D52318500DAA00EAA309 /* pc_encode.m */,
283 | 			);
284 | 			path = MATLAB;
285 | 			sourceTree = "<group>";
286 | 		};
287 | /* End PBXGroup section */
288 | 
289 | /* Begin PBXNativeTarget section */
290 | 		B31E0A2A181CBCF100E941E5 /* pc_simulate */ = {
291 | 			isa = PBXNativeTarget;
292 | 			buildConfigurationList = B31E0A31181CBCF100E941E5 /* Build configuration list for PBXNativeTarget "pc_simulate" */;
293 | 			buildPhases = (
294 | 				B31E0A27181CBCF100E941E5 /* Sources */,
295 | 				B31E0A28181CBCF100E941E5 /* Frameworks */,
296 | 				B31E0A29181CBCF100E941E5 /* CopyFiles */,
297 | 			);
298 | 			buildRules = (
299 | 			);
300 | 			dependencies = (
301 | 			);
302 | 			name = pc_simulate;
303 | 			productName = pc_simulate;
304 | 			productReference = B31E0A2B181CBCF100E941E5 /* pc_simulate */;
305 | 			productType = "com.apple.product-type.tool";
306 | 		};
307 | 		B3B71975181B0C5500055AD4 /* Test_double_ei */ = {
308 | 			isa = PBXNativeTarget;
309 | 			buildConfigurationList = B3B7197C181B0C5500055AD4 /* Build configuration list for PBXNativeTarget "Test_double_ei" */;
310 | 			buildPhases = (
311 | 				B3B71972181B0C5500055AD4 /* Sources */,
312 | 				B3B71973181B0C5500055AD4 /* Frameworks */,
313 | 				B3B71974181B0C5500055AD4 /* CopyFiles */,
314 | 			);
315 | 			buildRules = (
316 | 			);
317 | 			dependencies = (
318 | 			);
319 | 			name = Test_double_ei;
320 | 			productName = Test_double_ei;
321 | 			productReference = B3B71976181B0C5500055AD4 /* Test_double_ei */;
322 | 			productType = "com.apple.product-type.tool";
323 | 		};
324 | 		B3B71991181B0CFC00055AD4 /* pc_construction */ = {
325 | 			isa = PBXNativeTarget;
326 | 			buildConfigurationList = B3B71998181B0CFC00055AD4 /* Build configuration list for PBXNativeTarget "pc_construction" */;
327 | 			buildPhases = (
328 | 				B3B7198E181B0CFC00055AD4 /* Sources */,
329 | 				B3B7198F181B0CFC00055AD4 /* Frameworks */,
330 | 				B3B71990181B0CFC00055AD4 /* CopyFiles */,
331 | 			);
332 | 			buildRules = (
333 | 			);
334 | 			dependencies = (
335 | 			);
336 | 			name = pc_construction;
337 | 			productName = pc_construction;
338 | 			productReference = B3B71992181B0CFC00055AD4 /* pc_construction */;
339 | 			productType = "com.apple.product-type.tool";
340 | 		};
341 | 		B3E4D42F1843CE3700EAA309 /* Test_bec */ = {
342 | 			isa = PBXNativeTarget;
343 | 			buildConfigurationList = B3E4D4381843CE3700EAA309 /* Build configuration list for PBXNativeTarget "Test_bec" */;
344 | 			buildPhases = (
345 | 				B3E4D42C1843CE3700EAA309 /* Sources */,
346 | 				B3E4D42D1843CE3700EAA309 /* Frameworks */,
347 | 				B3E4D42E1843CE3700EAA309 /* CopyFiles */,
348 | 			);
349 | 			buildRules = (
350 | 			);
351 | 			dependencies = (
352 | 			);
353 | 			name = Test_bec;
354 | 			productName = Test_bec;
355 | 			productReference = B3E4D4301843CE3700EAA309 /* Test_bec */;
356 | 			productType = "com.apple.product-type.tool";
357 | 		};
358 | /* End PBXNativeTarget section */
359 | 
360 | /* Begin PBXProject section */
361 | 		B3B71934181B092300055AD4 /* Project object */ = {
362 | 			isa = PBXProject;
363 | 			attributes = {
364 | 				LastUpgradeCheck = 0500;
365 | 				ORGANIZATIONNAME = "Nicola De Franceschi";
366 | 			};
367 | 			buildConfigurationList = B3B71937181B092300055AD4 /* Build configuration list for PBXProject "PolarCodes" */;
368 | 			compatibilityVersion = "Xcode 3.2";
369 | 			developmentRegion = English;
370 | 			hasScannedForEncodings = 0;
371 | 			knownRegions = (
372 | 				en,
373 | 			);
374 | 			mainGroup = B3B71933181B092300055AD4;
375 | 			productRefGroup = B3B7193D181B092300055AD4 /* Products */;
376 | 			projectDirPath = "";
377 | 			projectRoot = "";
378 | 			targets = (
379 | 				B3B71975181B0C5500055AD4 /* Test_double_ei */,
380 | 				B3B71991181B0CFC00055AD4 /* pc_construction */,
381 | 				B31E0A2A181CBCF100E941E5 /* pc_simulate */,
382 | 				B3E4D42F1843CE3700EAA309 /* Test_bec */,
383 | 			);
384 | 		};
385 | /* End PBXProject section */
386 | 
387 | /* Begin PBXSourcesBuildPhase section */
388 | 		B31E0A27181CBCF100E941E5 /* Sources */ = {
389 | 			isa = PBXSourcesBuildPhase;
390 | 			buildActionMask = 2147483647;
391 | 			files = (
392 | 				B31E0A34181CBDDA00E941E5 /* channels.c in Sources */,
393 | 				B31E0A36181CBDDA00E941E5 /* double_ei.c in Sources */,
394 | 				B31E0A38181CBDDA00E941E5 /* pc_construction.c in Sources */,
395 | 				B31E0A3A181CBDDA00E941E5 /* pc_decode_internal.c in Sources */,
396 | 				B36B90AF181CCA41008E21AB /* error_rate.c in Sources */,
397 | 				B31E0A3C181CBDDA00E941E5 /* pc_decode.c in Sources */,
398 | 				B31E0A3E181CBDDA00E941E5 /* pc_encode.c in Sources */,
399 | 				B31E0A40181CBDDA00E941E5 /* polar_codes.c in Sources */,
400 | 				B31E0A42181CBDDA00E941E5 /* bhattacharyya_files.c in Sources */,
401 | 				B31E0A2E181CBCF100E941E5 /* main.c in Sources */,
402 | 			);
403 | 			runOnlyForDeploymentPostprocessing = 0;
404 | 		};
405 | 		B3B71972181B0C5500055AD4 /* Sources */ = {
406 | 			isa = PBXSourcesBuildPhase;
407 | 			buildActionMask = 2147483647;
408 | 			files = (
409 | 				B3B71981181B0CAB00055AD4 /* double_ei.c in Sources */,
410 | 				B3B7199C181B0D3100055AD4 /* main.c in Sources */,
411 | 			);
412 | 			runOnlyForDeploymentPostprocessing = 0;
413 | 		};
414 | 		B3B7198E181B0CFC00055AD4 /* Sources */ = {
415 | 			isa = PBXSourcesBuildPhase;
416 | 			buildActionMask = 2147483647;
417 | 			files = (
418 | 				B3B7199D181B127A00055AD4 /* channels.c in Sources */,
419 | 				B3B7199F181B127A00055AD4 /* double_ei.c in Sources */,
420 | 				B3B719A1181B127A00055AD4 /* pc_construction.c in Sources */,
421 | 				B3B719A3181B127A00055AD4 /* pc_decode_internal.c in Sources */,
422 | 				B36B90AE181CCA41008E21AB /* error_rate.c in Sources */,
423 | 				B3B719A5181B127A00055AD4 /* pc_decode.c in Sources */,
424 | 				B3B719A7181B127A00055AD4 /* pc_encode.c in Sources */,
425 | 				B3B719A9181B127A00055AD4 /* polar_codes.c in Sources */,
426 | 				B3B719AD181B15AE00055AD4 /* bhattacharyya_files.c in Sources */,
427 | 				B3B71995181B0CFC00055AD4 /* main.c in Sources */,
428 | 			);
429 | 			runOnlyForDeploymentPostprocessing = 0;
430 | 		};
431 | 		B3E4D42C1843CE3700EAA309 /* Sources */ = {
432 | 			isa = PBXSourcesBuildPhase;
433 | 			buildActionMask = 2147483647;
434 | 			files = (
435 | 				B3E4D4391843CE7200EAA309 /* channels.c in Sources */,
436 | 				B3E4D43A1843CE7200EAA309 /* channels.h in Sources */,
437 | 				B3E4D43B1843CE7200EAA309 /* double_ei.c in Sources */,
438 | 				B3E4D43C1843CE7200EAA309 /* double_ei.h in Sources */,
439 | 				B3E4D43D1843CE7200EAA309 /* pc_construction.c in Sources */,
440 | 				B3E4D43E1843CE7200EAA309 /* pc_construction.h in Sources */,
441 | 				B3E4D43F1843CE7200EAA309 /* pc_decode_internal.c in Sources */,
442 | 				B3E4D4401843CE7200EAA309 /* pc_decode_internal.h in Sources */,
443 | 				B3E4D4411843CE7200EAA309 /* pc_decode.c in Sources */,
444 | 				B3E4D4421843CE7200EAA309 /* pc_decode.h in Sources */,
445 | 				B3E4D4431843CE7200EAA309 /* pc_encode.c in Sources */,
446 | 				B3E4D4441843CE7200EAA309 /* pc_encode.h in Sources */,
447 | 				B3E4D4451843CE7200EAA309 /* polar_codes.c in Sources */,
448 | 				B3E4D4461843CE7200EAA309 /* polar_codes.h in Sources */,
449 | 				B3E4D4471843CE7200EAA309 /* bhattacharyya_files.c in Sources */,
450 | 				B3E4D4481843CE7200EAA309 /* bhattacharyya_files.h in Sources */,
451 | 				B3E4D4491843CE7200EAA309 /* error_rate.h in Sources */,
452 | 				B3E4D44A1843CE7200EAA309 /* error_rate.c in Sources */,
453 | 				B3E4D4331843CE3700EAA309 /* main.c in Sources */,
454 | 			);
455 | 			runOnlyForDeploymentPostprocessing = 0;
456 | 		};
457 | /* End PBXSourcesBuildPhase section */
458 | 
459 | /* Begin XCBuildConfiguration section */
460 | 		B31E0A32181CBCF100E941E5 /* Debug */ = {
461 | 			isa = XCBuildConfiguration;
462 | 			buildSettings = {
463 | 				GCC_PREPROCESSOR_DEFINITIONS = (
464 | 					"DEBUG=1",
465 | 					"$(inherited)",
466 | 				);
467 | 				MACOSX_DEPLOYMENT_TARGET = 10.8;
468 | 				PRODUCT_NAME = "$(TARGET_NAME)";
469 | 			};
470 | 			name = Debug;
471 | 		};
472 | 		B31E0A33181CBCF100E941E5 /* Release */ = {
473 | 			isa = XCBuildConfiguration;
474 | 			buildSettings = {
475 | 				MACOSX_DEPLOYMENT_TARGET = 10.8;
476 | 				PRODUCT_NAME = "$(TARGET_NAME)";
477 | 			};
478 | 			name = Release;
479 | 		};
480 | 		B3B71943181B092300055AD4 /* Debug */ = {
481 | 			isa = XCBuildConfiguration;
482 | 			buildSettings = {
483 | 				ALWAYS_SEARCH_USER_PATHS = NO;
484 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
485 | 				CLANG_CXX_LIBRARY = "libc++";
486 | 				CLANG_ENABLE_OBJC_ARC = YES;
487 | 				CLANG_WARN_BOOL_CONVERSION = YES;
488 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
489 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
490 | 				CLANG_WARN_EMPTY_BODY = YES;
491 | 				CLANG_WARN_ENUM_CONVERSION = YES;
492 | 				CLANG_WARN_INT_CONVERSION = YES;
493 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
494 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
495 | 				COPY_PHASE_STRIP = NO;
496 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
497 | 				GCC_DYNAMIC_NO_PIC = NO;
498 | 				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
499 | 				GCC_OPTIMIZATION_LEVEL = 0;
500 | 				GCC_PREPROCESSOR_DEFINITIONS = (
501 | 					"DEBUG=1",
502 | 					"$(inherited)",
503 | 				);
504 | 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
505 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
506 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
507 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
508 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
509 | 				GCC_WARN_UNUSED_FUNCTION = YES;
510 | 				GCC_WARN_UNUSED_VARIABLE = YES;
511 | 				MACOSX_DEPLOYMENT_TARGET = 10.8;
512 | 				ONLY_ACTIVE_ARCH = YES;
513 | 				SDKROOT = macosx;
514 | 			};
515 | 			name = Debug;
516 | 		};
517 | 		B3B71944181B092300055AD4 /* Release */ = {
518 | 			isa = XCBuildConfiguration;
519 | 			buildSettings = {
520 | 				ALWAYS_SEARCH_USER_PATHS = NO;
521 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
522 | 				CLANG_CXX_LIBRARY = "libc++";
523 | 				CLANG_ENABLE_OBJC_ARC = YES;
524 | 				CLANG_WARN_BOOL_CONVERSION = YES;
525 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
526 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
527 | 				CLANG_WARN_EMPTY_BODY = YES;
528 | 				CLANG_WARN_ENUM_CONVERSION = YES;
529 | 				CLANG_WARN_INT_CONVERSION = YES;
530 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
531 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
532 | 				COPY_PHASE_STRIP = YES;
533 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
534 | 				ENABLE_NS_ASSERTIONS = NO;
535 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
536 | 				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
537 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
538 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
539 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
540 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
541 | 				GCC_WARN_UNUSED_FUNCTION = YES;
542 | 				GCC_WARN_UNUSED_VARIABLE = YES;
543 | 				MACOSX_DEPLOYMENT_TARGET = 10.8;
544 | 				SDKROOT = macosx;
545 | 			};
546 | 			name = Release;
547 | 		};
548 | 		B3B7197D181B0C5500055AD4 /* Debug */ = {
549 | 			isa = XCBuildConfiguration;
550 | 			buildSettings = {
551 | 				GCC_PREPROCESSOR_DEFINITIONS = (
552 | 					"DEBUG=1",
553 | 					"$(inherited)",
554 | 				);
555 | 				MACOSX_DEPLOYMENT_TARGET = 10.8;
556 | 				PRODUCT_NAME = "$(TARGET_NAME)";
557 | 			};
558 | 			name = Debug;
559 | 		};
560 | 		B3B7197E181B0C5500055AD4 /* Release */ = {
561 | 			isa = XCBuildConfiguration;
562 | 			buildSettings = {
563 | 				MACOSX_DEPLOYMENT_TARGET = 10.8;
564 | 				PRODUCT_NAME = "$(TARGET_NAME)";
565 | 			};
566 | 			name = Release;
567 | 		};
568 | 		B3B71999181B0CFC00055AD4 /* Debug */ = {
569 | 			isa = XCBuildConfiguration;
570 | 			buildSettings = {
571 | 				GCC_PREPROCESSOR_DEFINITIONS = (
572 | 					"DEBUG=1",
573 | 					"$(inherited)",
574 | 				);
575 | 				PRODUCT_NAME = "$(TARGET_NAME)";
576 | 			};
577 | 			name = Debug;
578 | 		};
579 | 		B3B7199A181B0CFC00055AD4 /* Release */ = {
580 | 			isa = XCBuildConfiguration;
581 | 			buildSettings = {
582 | 				PRODUCT_NAME = "$(TARGET_NAME)";
583 | 			};
584 | 			name = Release;
585 | 		};
586 | 		B3E4D4361843CE3700EAA309 /* Debug */ = {
587 | 			isa = XCBuildConfiguration;
588 | 			buildSettings = {
589 | 				GCC_PREPROCESSOR_DEFINITIONS = (
590 | 					"DEBUG=1",
591 | 					"$(inherited)",
592 | 				);
593 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
594 | 				PRODUCT_NAME = "$(TARGET_NAME)";
595 | 			};
596 | 			name = Debug;
597 | 		};
598 | 		B3E4D4371843CE3700EAA309 /* Release */ = {
599 | 			isa = XCBuildConfiguration;
600 | 			buildSettings = {
601 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
602 | 				PRODUCT_NAME = "$(TARGET_NAME)";
603 | 			};
604 | 			name = Release;
605 | 		};
606 | /* End XCBuildConfiguration section */
607 | 
608 | /* Begin XCConfigurationList section */
609 | 		B31E0A31181CBCF100E941E5 /* Build configuration list for PBXNativeTarget "pc_simulate" */ = {
610 | 			isa = XCConfigurationList;
611 | 			buildConfigurations = (
612 | 				B31E0A32181CBCF100E941E5 /* Debug */,
613 | 				B31E0A33181CBCF100E941E5 /* Release */,
614 | 			);
615 | 			defaultConfigurationIsVisible = 0;
616 | 			defaultConfigurationName = Release;
617 | 		};
618 | 		B3B71937181B092300055AD4 /* Build configuration list for PBXProject "PolarCodes" */ = {
619 | 			isa = XCConfigurationList;
620 | 			buildConfigurations = (
621 | 				B3B71943181B092300055AD4 /* Debug */,
622 | 				B3B71944181B092300055AD4 /* Release */,
623 | 			);
624 | 			defaultConfigurationIsVisible = 0;
625 | 			defaultConfigurationName = Release;
626 | 		};
627 | 		B3B7197C181B0C5500055AD4 /* Build configuration list for PBXNativeTarget "Test_double_ei" */ = {
628 | 			isa = XCConfigurationList;
629 | 			buildConfigurations = (
630 | 				B3B7197D181B0C5500055AD4 /* Debug */,
631 | 				B3B7197E181B0C5500055AD4 /* Release */,
632 | 			);
633 | 			defaultConfigurationIsVisible = 0;
634 | 			defaultConfigurationName = Release;
635 | 		};
636 | 		B3B71998181B0CFC00055AD4 /* Build configuration list for PBXNativeTarget "pc_construction" */ = {
637 | 			isa = XCConfigurationList;
638 | 			buildConfigurations = (
639 | 				B3B71999181B0CFC00055AD4 /* Debug */,
640 | 				B3B7199A181B0CFC00055AD4 /* Release */,
641 | 			);
642 | 			defaultConfigurationIsVisible = 0;
643 | 			defaultConfigurationName = Release;
644 | 		};
645 | 		B3E4D4381843CE3700EAA309 /* Build configuration list for PBXNativeTarget "Test_bec" */ = {
646 | 			isa = XCConfigurationList;
647 | 			buildConfigurations = (
648 | 				B3E4D4361843CE3700EAA309 /* Debug */,
649 | 				B3E4D4371843CE3700EAA309 /* Release */,
650 | 			);
651 | 			defaultConfigurationIsVisible = 0;
652 | 			defaultConfigurationName = Release;
653 | 		};
654 | /* End XCConfigurationList section */
655 | 	};
656 | 	rootObject = B3B71934181B092300055AD4 /* Project object */;
657 | }
658 | 


--------------------------------------------------------------------------------