mojin

import numpy as np

# making frames with Gaussian noise
def makeframes(mu,sigma):
    frames = np.random.normal(mu,sigma,(100,2500))
    return(frames)

# making reference using median combination
def medianref(frames):
    ref_med = np.median(frames, axis=0)
    return(ref_med)

# subtracting median reference
def mediansub(frames,ref_med_input):
    ref_med_mat = np.tile(ref_med_input, (100,1))
    results = frames - ref_med_mat
    return(results)

# making reference with random coefficients
def randomref(frames):
    reference = np.zeros((100,2500))
    for i in range(100):
        coeff_raw = (np.random.rand(100)-0.5)/5.  # (100)
        coeff = coeff_raw/np.sum(coeff_raw) # (100)
        ref_ran = np.sum(np.multiply(frames.T, coeff), axis=1)  # (2500)
        reference[i]=ref_ran
    return(reference)

# subtracting random reference
def randomsub(frames,ref_ran_input):
    results = frames - ref_ran_input
    return(results)

# combining into one frame
def combine(result_input):
    result = np.median(result_input, axis=0)
    return(result)

# calculating mean and std
def calc(frame):
    mean = np.mean(frame)
    sig = np.std(frame)
    return(mean, sig)

# main
if __name__ == '__main__':

    mu = 100.
    sigma = 10.

    np.random.seed(seed=100)

    frames = makeframes(mu,sigma)
    medref = medianref(frames)
    result_med = mediansub(frames,medref)
    ret = calc(result_med)
    print('median combination')
    print('mean=%f sigma=%f' % (ret[0],ret[1]))

    frames = makeframes(mu,sigma)
    ranref = randomref(frames)
    result_ran = randomsub(frames,ranref)
    comb_ran = combine(result_ran)
    ret = calc(comb_ran)
    print 'random combination'
    print('mean=%f sigma=%f' % (ret[0],ret[1]))

skylab13 (slightly modified)

import math
import sys
import os
import random
import numpy

# making frames with Gaussian noise

def makeframes(mu,sigma):
    frames = numpy.array(numpy.zeros((100,2500),'f'))
    for i in range(0,100):
        data = numpy.array(numpy.zeros((2500),'f'))
        for j in range(0,2500):
#            data[j] = random.gauss(mu,sigma)
            data[j] = numpy.random.normal(mu,sigma)
        frames[i] = data
    return frames

# making reference using median combination

def medianref(frames):
    ref_med = numpy.array(numpy.zeros((2500),'f'))
    inverse = numpy.array(numpy.zeros((2500,100),'f'))
    inverse = frames.T
    for j in range(0,2500):
        ref_med[j]= numpy.ma.median(inverse[j])
    return ref_med

# making reference with random coefficients
        
def randomref(frames):
    coeff = numpy.array(numpy.zeros((100),'f'))
    coeff_raw = numpy.array(numpy.zeros((100),'f'))
    reference = numpy.array(numpy.zeros((100,2500),'f'))
    ref_ran = numpy.array(numpy.zeros((2500),'f'))
    sum = 0.

    for i in range(0,100):
        ref_ran = numpy.zeros((2500),'f')
        sum=0.
        for l in range(0,100):
#            coeff_raw[l]=(random.random()-0.5)/5.
            coeff_raw[l]=(numpy.random.rand()-0.5)/5.
            sum += coeff_raw[l]
        for l in range(0,100):
            coeff[l]=coeff_raw[l]/sum

        for j in range(0,2500):
            for k in range(0,100):
                ref_ran[j] += frames[k][j]*coeff[k]
        reference[i]=ref_ran
    return reference

# subtracting median reference

def mediansub(frames,ref_med_input):
    results = numpy.array(numpy.zeros((100,2500),'f'))
    result = numpy.array(numpy.zeros((2500),'f'))
    frame = numpy.array(numpy.zeros((2500),'f'))
    for j in range(0,100):
        frame = frames[j]
        result=frame-ref_med_input
        results[j]=result
    return results

# subtracting random reference

def randomsub(frames,ref_ran_input):
    results = numpy.array(numpy.zeros((100,2500),'f'))
    result =numpy.array(numpy.zeros((2500),'f'))
    for i in range(0,100):
        frame = frames[i]
        reference = ref_ran_input[i]
        for j in range(0,2500):
            result[j]=frame[j]-reference[j]
        results[i]=result
    return results

# combining into one frame

def combine(result_input):
    inverse = numpy.array(numpy.zeros((2500,100),'f'))
    inverse = result_input.T
    result = numpy.array(numpy.zeros((2500),'f'))
    for k in range(0,2500):
        result[k] = numpy.ma.median(inverse[k])
    return result

# calculating mean and std

def calc(frame):
    mean = numpy.mean(frame)
    sig = numpy.std(frame)
    return mean, sig

# main

if __name__ == '__main__':
    mu = 100.
    sigma = 10.

    numpy.random.seed(seed=100)

    frames = makeframes(mu,sigma)
    medref = medianref(frames)
    result_med = mediansub(frames,medref)
#    comb_med = combine(result_med)
#    ret = calc(comb_med)
    ret = calc(result_med)
    print 'median combination'
    print 'mean=',ret[0], 'sigma=',ret[1]

    frames = makeframes(mu,sigma)
    ranref = randomref(frames)
    result_ran = randomsub(frames,ranref)
    comb_ran = combine(result_ran)
    ret = calc(comb_ran)
    print 'random combination'
    print 'mean=',ret[0], 'sigma=',ret[1]