repo2/atari_chips/pokeyv2/SID/investigation/approx.m
| 1186 | markw | close all;
|
|
figure;
|
|||
hold all;
|
|||
%stepsize = (16/32768);
|
|||
%x=-8:stepsize:8;
|
|||
TYPE3_W0S_RESOLUTION = 1 / 5e3;
|
|||
%x = x.*10.2;
|
|||
sigmoidreal = @(x) 1./(1.+e.^-x);
|
|||
sigmoidapprox1 = @(x) 1./(1.+2.^(-1.5.*x)); %Approx, but what does it give us?
|
|||
sigmoidapprox2 = @sig_sigmoid; %Approx, but what does it give us?
|
|||
func = sigmoidreal;
|
|||
%See minf/maxf;
|
|||
rescale = 0.133923834850281;
|
|||
reoffset = 0.00188312488556502;
|
|||
scalefunc = @(x) (x.*rescale .+ reoffset);
|
|||
func = @(x) scalefunc(func(x));
|
|||
%func = sigmoidreal;
|
|||
test = csvread('/home/markw/fpga/svn/repo/trunk/atari_800xl/atari_chips/pokeyv2/SID/investigation/output_6.csv');
|
|||
s1 = test(test(:,1)==1,:);
|
|||
| 1263 | markw | locoffset = -9.74126000000000;
|
|
locscale = 0.00664125000000000;
|
|||
| 1186 | markw | %besterr = 2.79586225092504e-08
|
|
loc = locoffset+(s1(:,5)*locscale);
|
|||
vals2 = nan(512,1024);
|
|||
%So, lookup in loc then add i*delta to get the func pos...
|
|||
%loc can be stored in flash rom
|
|||
%we need to compute param for sigmoid
|
|||
%sigmoid(vol*delta + loc)
|
|||
stepsize = (16/1024);
|
|||
funclookup = func(-8:stepsize:(8-stepsize));
|
|||
| 1263 | markw | %numel(unique(funclookup))
|
|
| 1186 | markw | ||
delta = 0.0652017000000000; %median - real sigmoid
|
|||
| 1263 | markw | %shiftlookup = nan(1,512);
|
|
| 1186 | markw | ||
%each step is TYPE3_W0S_RESOLUTION
|
|||
%which is kind of annoying, lets make it 1/4096 instead
|
|||
%0-1275000
|
|||
%(255/(1/5000))*(1/4096);
|
|||
FAST_W0S_RESOLUTION = 1/4096;
|
|||
adjres = (TYPE3_W0S_RESOLUTION/FAST_W0S_RESOLUTION);
|
|||
| 1263 | markw | %for i=1:512
|
|
% shiftlookup(i) = adjres*delta*(i-1);
|
|||
%end
|
|||
| 1186 | markw | ||
locstep = loc*(1/stepsize);
|
|||
| 1263 | markw | %shiftlookup = shiftlookup*(1/stepsize);
|
|
%shiftlookup = shiftlookup + -1 +numel(funclookup)/2;
|
|||
%debug> polyfit(1:numel(shiftlookup),shiftlookup,1)
|
|||
%ans =
|
|||
%
|
|||
% 3.4184 507.5816
|
|||
| 1186 | markw | ||
| 1263 | markw | locstepc = locstep+507.5816;
|
|
funclookup2 = interp1(1:numel(funclookup),funclookup,1:(3.4184):numel(funclookup));
|
|||
%N = numel(-8:stepsize:(8-stepsize));
|
|||
%funclookup2 = func(1:(3.4184):N);
|
|||
figure;
|
|||
%t = 1:(2^18/65):(2^18-1);
|
|||
%sigmoidreal = @(x) 1./(1.+e.^-x);
|
|||
%t = sigmoidreal(-4+8*t/2^18);
|
|||
%t=funclookup2(1) + t*(funclookup2(300)-funclookup2(1))
|
|||
locstepc = 3.4184+(locstepc/3.4184);
|
|||
| 1186 | markw | for i=1:256
|
|
| 1263 | markw | %shift = shiftlookup(i); %lookup shift (when vol changed enough) - straigh line...
|
|
%shift = 3.4184*i+507.5816;
|
|||
%shiftnc = 3.4184*i;
|
|||
shiftnc = i-1;
|
|||
%lookup loc (when f reg changed)
|
|||
%idx = locstep + shift; %adder
|
|||
idx = locstepc + shiftnc; %adder
|
|||
idx = min(max(1,idx),numel(funclookup2)); %cap
|
|||
vals2(i,:) = funclookup2(round(idx)); %lookup sigmoid (when sum changed)
|
|||
%vals2(i,:) = func(round(idx)); %lookup sigmoid (when sum changed)
|
|||
| 1186 | markw | ||
%vals2(i,:) = func(loc.+(delta*(i-1)));
|
|||
%should work, but ... fast enough? 10 + 10 + 10 -> 30 cycles -> say 1.8MHz to update f? Probably ok...
|
|||
end
|
|||
| 1263 | markw | %For vhdl... also in slope.m
|
|
figure
|
|||
sigmoidvhdl=funclookup2(round(1:299/64:300));
|
|||
plot(sigmoidvhdl)
|
|||
rescale = 0.133923834850281;
|
|||
reoffset = 0.00188312488556502;
|
|||
sv2 = sigmoidreal(-8:16/64:8)*rescale + reoffset;
|
|||
hold all
|
|||
plot(sv2);
|
|||
for i=1:numel(sv2)
|
|||
fprintf('"%s",',dec2bin(floor((2^18-1)*sv2(i)),18));
|
|||
endfor
|
|||
%For rom compute code
|
|||
| 1186 | markw | %scale
|
|
minf = 0.0018910;
|
|||
maxf = 0.13305;
|
|||
v2min = min(vals2(1,:));
|
|||
v2max = max(vals2(1,:));
|
|||
%vals2 = vals2.-v2min;
|
|||
%vals2 = vals2./(v2max-v2min);
|
|||
%vals2 = vals2.*(maxf-minf);
|
|||
%vals2 = vals2.+minf;
|
|||
%rescale = (maxf-minf)./(v2max-v2min);
|
|||
%vals2 = vals2.*rescale;
|
|||
%vals2 = vals2.+minf.-(v2min.*rescale);
|
|||
%We can also store these magic numbers... flash? or can we make a sigmoid with this scale from logic elements
|
|||
rescale = 0.133923834850281;
|
|||
reoffset = 0.00188312488556502;
|
|||
%vals2 = vals2.*rescale .+ reoffset;
|
|||
range = 0:1275000/20:1275000;
|
|||
range256 = 0:1275000/255:1275000;
|
|||
v1lookup = @(i) 1.+round(i.*TYPE3_W0S_RESOLUTION);
|
|||
v2lookup = @(i) 1.+floor(i.*FAST_W0S_RESOLUTION);
|
|||
%figure
|
|||
hold all;
|
|||
for i=range
|
|||
plot(vals2(v2lookup(i),:));
|
|||
end
|
|||
vals = load('valsorig.mat','vals');
|
|||
vals = vals.vals;
|
|||
for i=range
|
|||
plot(vals(v1lookup(i),:));
|
|||
end
|
|||
figure;
|
|||
plot(vals(1,:));
|
|||
hold all;
|
|||
plot(vals2(1,:));
|
|||
figure;
|
|||
plot((vals2(1,:).-vals(1,:))./maxf);
|
|||
vals_interp = nan(256,1024);
|
|||
vals_interp2 = nan(256,1024);
|
|||
for i = 1:numel(range256);
|
|||
vals_interp(i,:) = vals(v1lookup(range256(i)),:);
|
|||
vals_interp2(i,:) = vals2(v2lookup(range256(i)),:);
|
|||
end
|
|||
pause(2);
|
|||
figure;
|
|||
mesh((vals_interp2.-vals_interp)./maxf);
|
|||
pause(2);
|
|||
figure;
|
|||
hold all;
|
|||
for i=range
|
|||
plot(vals(v1lookup(i),:));
|
|||
end
|
|||
figure;
|
|||
hold all;
|
|||
for i=range
|
|||
plot(vals2(v2lookup(i),:));
|
|||
end
|