def Skew_Term_plot(sigma, v0, kappa, rho, theta):
parameters = [sigma, v0, kappa, rho, theta]
param_name = ['sigma', 'v0', 'kappa', 'rho', 'theta']
chg_var = [parameters.index(v) for v in parameters
if isinstance(v, list)][0]
title = 'Impact of ' + param_name[chg_var]
fig, ax = plt.subplots(nrows=1, ncols=2)
fig.suptitle(title, size=20)
if chg_var == 0:
variable = sigma
for var in variable:
b = FFT(var, v0, kappa, rho, theta, S0=150, r=0.025, T=0.25)
K_T_vol_analysis(b, alpha, ax, variable)
elif chg_var == 1:
variable = v0
for var in variable:
b = FFT(sigma, var, kappa, rho, theta, S0=150, r=0.025, T=0.25)
K_T_vol_analysis(b, alpha, ax, variable)
elif chg_var == 2:
variable = kappa
for var in variable:
b = FFT(sigma, v0, var, rho, theta, S0=150, r=0.025, T=0.25)
K_T_vol_analysis(b, alpha, ax, variable)
elif chg_var == 3:
variable = rho
for var in variable:
b = FFT(sigma, v0, kappa, var, theta, S0=150, r=0.025, T=0.25)
K_T_vol_analysis(b, alpha, ax, variable)
elif chg_var == 4:
variable = theta
for var in variable:
b = FFT(sigma, v0, kappa, rho, var, S0=150, r=0.025, T=0.25)
K_T_vol_analysis(b, alpha, ax, variable)
def main():
path = 'C:/Users/2015136133/Desktop/' #경로
fft1 = FFT.FFT()
fft2 = FFT.FFT()
fft3 = FFT.FFT()
startFun(fft1, path + 'fft1.wav') #FFT 과정을 수행함
startFun(fft2, path + 'fft2.wav') #FFT 과정을 수행함
startFun(fft3, path + 'fft3.wav') #FFT 과정을 수행함
#fft1.showPltFFT()
#fft2.showPltFFT()
#fft3.showPltFFT()
fftavg = [((fft1.fftdata[i] + fft2.fftdata[i] + fft3.fftdata[i]) / 3) for i in range(len(fft1.fftdata))]
# fft1, 2, 3의 평균값을 fftavg에다 넣어줌
fft4 = FFT.FFT()
startFun(fft4,path + 'fft4.wav')
cnt = 0
for i in range(len(fft4.fftdata)):
if errrate(fftavg[i],fft4.fftdata[i]) > 70:
cnt+=1
print((cnt/len(fftavg)*100), '% 입니다.')
FFT.FFT.saveTextFile(fft1.freq, fftavg, path + 'avgfft.txt') #fft 평균을 txt로 저장
def PCreateFFT(image, dir):
"""
Create an FFT object suitable for FFTing an image
Create an FFT for an efficient size equal to or larger than image
One needed for each direction to be FFTed.
returns Python FFT object
* image = Image to be FFTed
* dir = FFT direction 1 -> R2C, 2 -> C2R
"""
################################################################
# Checks
if not Image.PIsA(image):
raise TypeError("image MUST be a Python Obit Image")
#
# Get image info from descriptor
desc = image.Desc
descDict = desc.Dict
rank = 2 # Only 2D FFTs
dim = descDict["inaxes"]
# Compute size to be efficient
i = 0
effDim = []
for x in dim:
effDim.append(FFT.PSuggestSize(x))
i = i+1
effDim
name = "FFT for " + Image.PGetName(image)
out = FFT.FFT(name, dir, 2, rank, effDim)
return out
def compress(filename="lena.mn",
output_filename="lena",
compression_factor=.5):
'''Writes a compressed mnc file.
The number of values kept is the (orginal number)*(compression_factor).
This version of the compression function acts on square images only.'''
data = read_mn(filename)
transformed_data = FFT(data)
col_length = len(transformed_data) #also equals the number of rows
row_length = len(transformed_data[0]) #also equals the number of columns
#flatten the array:
transformed_data = transformed_data.reshape(
(1, np.multiply(*transformed_data.shape)))[0]
#given a compression factor, compression threshold is the value below which the...
#function throws away frequency in the FFT data
compression_threshold = {'real': 0, 'imag': 0}
compression_threshold['real'] = find_threshold(transformed_data.real,
compression_factor)
compression_threshold['imag'] = find_threshold(transformed_data.imag,
compression_factor)
#by symmetry, the lower half of the data can be reproduced by the top half, excluding the first row
upper_half = np.array(transformed_data[:(col_length / 2 + 1) * row_length])
#split FFT data into two pieces, real and imag
uh_real = upper_half.real
uh_imag = upper_half.imag
#throw away small values using compression threshold
uh_real = np.array(
[i if abs(i) > compression_threshold['real'] else 0 for i in uh_real])
uh_imag = np.array(
[i if abs(i) > compression_threshold['imag'] else 0 for i in uh_imag])
#writes to mnc file
write_mnc(output_filename + ".mnc",
np.around(uh_real).astype('int'),
np.around(uh_imag).astype('int'), (len(data), len(data)),
(1, 0, 1, 0))
def __init__(self, input_token, threaded=True, kwargs_dict={}):
"""
The class implements the math processor abstract class
the arguments in **kwargs are:
window_duration
window_start
number_of_steps
animated (if False means only one single frame of fft is calculated)
"""
window_duration_text = 'window_duration'
window_start_text = 'window_start'
number_of_steps_text = 'number_of_steps'
animated_text = 'animated'
if (not window_duration_text in kwargs_dict
or not window_start_text in kwargs_dict
or not number_of_steps_text in kwargs_dict
or not animated_text in kwargs_dict):
raise NecessaryArgNotPresent
self.__window_duration = kwargs_dict[window_duration_text]
self.__window_start = kwargs_dict[window_start_text]
self.__number_of_steps = kwargs_dict[number_of_steps_text]
self.__animated = kwargs_dict[animated_text]
super().__init__(input_token, threaded)
## The queue to hold fft responses as a function of their
## start time
self.__fft_frames_queue = queue.Queue()
self.__fft_calculator = FFT.FFT()
def pdata():
while (endFlag == 0):
for i in range(16):
data = sdr.read_samples(CHUNK)
# data=[0.1+0.1j]*CHUNK
F = FFT.FFT(data, level)
q.put(F)
print('endFlag=', endFlag)
exit()
def recolectar(self, *args):
xp = self.xp.get()
hp = self.hp.get()
if (xp & hp):
messagebox.showinfo(message="Solo debe marcar una opción", title="Resultado")
return;
if ((not xp) & (not hp)):
messagebox.showinfo(message="Debe marcar una opción", title="Resultado")
return;
if (xp & (not hp)):
x = self.x.get()
messagebox.showinfo(message=FFT(formato(x)), title="Resultado")
if ((not xp) & hp):
x = self.x.get()
messagebox.showinfo(message=IFFT(formato(x)), title="Resultado")
def getSpectrogram(x):
spectrums = []
i = 0
## print len(x)
while i < len(
x
) - windowSize - 1: # I ignore the last incomplete window, or we could deal with it using padding technique
# For a new window, initiate a list
waves = []
for j in range(0, windowSize):
waves.append(x[i + j])
win = FFT.FFT(waves)
spectrums.append(win)
i = i + overlap
return spectrums
v0 = 0.09
kappa = 0.5
rho = 0.25
theta = 0.12
S0 = 150
K = 150
r = 0.025
T = 0.25
n = 10
B = K * 2.7
alpha = 1.5
# (b) i
b = FFT(sigma, v0, kappa, rho, theta, S0, r, T)
# K_vol_analysis(b, alpha, n, B, K)
# (b) ii
T_vol_analysis(b, alpha, n, B, K)
# # (b) iii
# Impact of Sigma
Skew_Term_plot([0.5, 0.6, 0.7], 0.09, 0.5, 0.25, 0.12)
# Impact of V0
Skew_Term_plot(0.4, [0.1, 0.12, 0.14], 0.5, 0.25, 0.12)
# Impact of k
Skew_Term_plot(0.4, 0.09, [0.6, 0.8, 1.0], 0.25, 0.12)
# Impact of rho
Skew_Term_plot(0.4, 0.09, 0.5, [0.35, 0.45, 0.55], 0.12)
# # Impact of theta
def joint_all_data(first_day_data, data, last_day_data):
data = np.append(first_day_data, data)
data = np.append(data, last_day_data)
return data
if __name__ == "__main__":
first_day_date,first_day_data,date_list,data,last_day_date,last_day_data, imputation_array = \
readone('/media/demcare/1.4T_Linux/UKBiobank/sample.csv')
#print first_day_date,first_day_data.shape
#print date_list,data.shape
#print last_day_date,last_day_data.shape
data = joint_all_data(first_day_data, data, last_day_data)
#print data
#d= np.asarray([d],dtype='float64')
fs = 1/5.0
FFT.FFT('CPU',data,fs)
'''x = T.matrix('x', dtype='float64')
rfft = fft.rfft(x, norm='ortho')
#rfft = fft.rfft(x)
f_rfft = theano.function([x], rfft)
import time
start = time.time()
out = f_rfft(d)
print time.time() - start
start = time.time()
f, Pxx_den = signal.periodogram(d, fs)
print time.time() - start
start = time.time()
S0 = 282
r = 0.015
q = 0.0177
T = 1
Option_params = [S0, T, r, q]
### problem 2 ###
steps = 250
N = 100000
### problem 3 ###
K = 285
simu_S = Simu_Heston_Path(steps, N, Option_params, Heston_params)
euro_simu = cal_Euro(simu_S, r, T, K, opt_type='c')
euro_FFT = FFT(Heston_params, T, S0, r, q).Heston_fft(alpha=1.5,
K=K,
B=K * 2.5)
print('European Call price through Simulation is:', euro_simu)
print('European Call price through FFT is:', euro_FFT)
### problem 4 ###
K1 = 285
K2 = 315
simu_S = Simu_Heston_Path(steps, N, Option_params, Heston_params)
UAO_price = cal_UpAndOut(simu_S, r, T, K1, K2)
print('Up-And-Out Call price through simulation is:', UAO_price)
Ns = np.logspace(1, 4.9, 400)
UpAndOut = []
for sample_N in Ns:
sample_index = np.random.choice(N, int(sample_N), replace=False)
ionames += [
'io_in_bits_%s_real' % (count),
'io_in_bits_%s_imag' % (count)
]
self.iofile_bundle.Members[name].verilog_connectors=\
self.tb.connectors.list(names=ionames)
self.iofile_bundle.Members[name].verilog_io_condition = 'initdone'
self.tb.generate_contents()
if __name__ == "__main__":
import matplotlib.pyplot as plt
from FFT import *
from FFT.controller import controller as FFT_controller
dut = FFT()
dut2 = FFT()
dut.model = 'py'
dut2.model = 'sv'
#dut2.interactive_verilog=True
len = 16 * 64
phres = 64
fsig = 25e6
indata=2**10*np.exp(1j*2*np.pi/phres*(np.arange(len)*np.round(fsig/dut.Rs*phres)))\
.reshape(-1,64)
controller = FFT_controller()
controller.reset()
dut.io_in.Data = indata
dut2.io_in.Data = indata
dut.control_write = controller.control_write
dut2.control_write = controller.control_write
def cal_Heston_price(K, Ks, T, alpha, params):
prices = FFT(params, T).Heston_fft(alpha, K, B=K * 2.5, Ks=Ks)
return prices
def PImageFFT(inImage, outAImage, outPImage, err):
"""
FFTs an Image
FFT inImage and write as real and imaginary as full plane (hermetian)
* inImage = input Obit Python Image 1
Any BLC and/or TRC set will be honored
* outAImage = output Obit Python Amplitude image of FFT
must be defined but not instantiated
* outPImage = output Obit Python Phase (deg) image of FFT
must be defined but not instantiated
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not Image.PIsA(inImage):
raise TypeError("inImage MUST be a Python Obit Image")
if not Image.PIsA(outAImage):
raise TypeError("outAImage MUST be a Python Obit Image")
if not Image.PIsA(outPImage):
raise TypeError("outPImage MUST be a Python Obit Image")
if not err.IsA():
raise TypeError("err MUST be an OErr")
#
# Clone output images
inImage.Clone(outAImage, err)
inImage.Clone(outPImage, err)
OErr.printErrMsg(err, "Error initializing images")
# Size of FFT
inImage.Open(Image.READONLY, err)
inImage.Read(err)
OErr.printErrMsg(err, "Error reading input")
inHead = inImage.Desc.Dict
FFTdim = [
FFT.PSuggestSize(inHead["inaxes"][0]),
FFT.PSuggestSize(inHead["inaxes"][1])
]
# Create float arrays for FFT size
inFArray = FArray.FArray("inF", naxis=FFTdim)
outFArray = FArray.FArray("outF", naxis=FFTdim)
# Create FFT for full complex FFT
FFTfor = FFT.FFT("FFT", 1, 1, 2, FFTdim)
# Create complex arrays for FFT size
inCArray = CArray.CArray("inC", naxis=FFTdim)
outCArray = CArray.CArray("outC", naxis=FFTdim)
#Loop over planes
nplane = inImage.Desc.Dict['inaxes'][2]
for iax in range(1, nplane + 1):
inImage.GetPlane(None, [iax, 1, 1, 1, 1], err)
OErr.printErrMsg(err, "Error reading input")
# Pad input into work FArray
FArray.PPad(inImage.FArray, inFArray, 1.0)
# and God said "The center of an FFT will be at the corners"
FArray.PCenter2D(inFArray)
# Zero output FArray and use as imaginary part
FArray.PFill(outFArray, 0.0)
# Copy input to scratch CArray
CArray.PComplex(inFArray, outFArray, inCArray)
# FFT
FFT.PC2C(FFTfor, inCArray, outCArray)
# Extract amplitude, write
CArray.PAmp(outCArray, outFArray)
# and God said "The center of an FFT will be at the corners"
FArray.PCenter2D(outFArray)
outAImage.FArray = FeatherUtil.PExtract(FFTfor, outFArray,
outAImage.FArray, err)
OErr.printErrMsg(err, "Error extracting output amplitude plane")
outAImage.PutPlane(outAImage.FArray, [iax, 1, 1, 1, 1], err)
# Extract phase, write
CArray.PPhase(outCArray, outFArray)
# To degrees
FArray.PSMul(outFArray, 57.2956)
# and God said "The center of an FFT will be at the corners"
FArray.PCenter2D(outFArray)
outPImage.FArray = FeatherUtil.PExtract(FFTfor, outFArray,
outPImage.FArray, err)
OErr.printErrMsg(err, "Error extracting output phase plane")
outPImage.PutPlane(outPImage.FArray, [iax, 1, 1, 1, 1], err)
# Error?
OErr.printErrMsg(err, "Error writing output phase image")
# end loop over planes
# Fix headers
outAImage.Open(Image.READWRITE, err)
FFTHeaderUpdate(outAImage, FFTdim, err)
outAImage.Close(err)
OErr.printErrMsg(err, "Error writing output amplitude image")
outPImage.Open(Image.READWRITE, err)
FFTHeaderUpdate(outPImage, FFTdim, err)
outPImage.Close(err)
OErr.printErrMsg(err, "Error writing output phase image")
# get any BLC, TRC for history
info = inImage.List.Dict
blc = [1, 1, 1, 1, 1, 1, 1]
if 'BLC' in info:
blc = info["BLC"][2]
trc = [0, 0, 0, 0, 0, 0, 0]
if 'TRC' in info:
trc = info["TRC"][2]
# Write history
i = 0
imtype = ("Amplitude", "Phase")
for outImage in (outAImage, outPImage):
inHistory = History.History("history", inImage.List, err)
outHistory = History.History("history", outImage.List, err)
# Copy History
# FITS? - copy header
if ("FileType" in info) and (info["FileType"][2][0] == 0):
History.PCopyHeader(inHistory, outHistory, err)
#Not needed History.PCopy(inHistory, outHistory, err)
# Add this programs history
outHistory.Open(History.READWRITE, err)
outHistory.TimeStamp(" Start Obit PImageFFT", err)
outHistory.TimeStamp(OSystem.PGetPgmName() + " BLC = " + str(blc), err)
outHistory.TimeStamp(OSystem.PGetPgmName() + " TRC = " + str(trc), err)
outHistory.TimeStamp(OSystem.PGetPgmName() + " type = " + imtype[i],
err)
i += 1
outHistory.Close(err)
import LEDWall
import FFT
import SharedVariables
import pong
from pong_flask_resource import PongControl
import threading
import sys
import time
from flask import Flask, request
from flask_restful import Resource, Api, reqparse
import numpy as np
shared_vars = SharedVariables.SharedVariables()
ledwall = LEDWall.LEDWall()
fft = FFT.FFT()
pong_game = pong.Pong()
flaskApp = Flask(__name__)
flaskApi = Api(flaskApp)
threads = []
def kill_threads():
shared_vars.kill_threads = True
for t in threads:
t.join()
threads.clear()
shared_vars.kill_threads = False
ledwall.show_color((0, 0, 0))
inHead = inImage.Desc.Dict
FFTdim = [FFT.PSuggestSize(inHead["inaxes"][0]), FFT.PSuggestSize(inHead["inaxes"][1])]
# Create float arrays for FFT size
inFArray = FArray.FArray("inF", naxis=FFTdim)
outFArray = FArray.FArray("outF", naxis=FFTdim)
# Pad input into work FArray
FArray.PPad(inImage.FArray, inFArray, 1.0)
# and God said "The center of an FFT will be at the corners"
FArray.PCenter2D(inFArray)
# Zero output FArray and use as imaginary part
FArray.PFill(outFArray, 0.0)
# Create FFT for full complex FFT
FFTfor = FFT.FFT("FFT", 1, 1, 2, FFTdim)
# Create complex arrays for FFT size
inCArray = CArray.CArray("inC", naxis=FFTdim)
outCArray = CArray.CArray("outC", naxis=FFTdim)
# Copy input to scratch CArray
CArray.PComplex(inFArray, outFArray, inCArray)
# FFT
FFT.PC2C(FFTfor, inCArray, outCArray)
# Extract amplitude
CArray.PAmp(outCArray, outFArray)
# and God said "The center of an FFT will be at the corners"
FArray.PCenter2D(outFArray)
