I have been looking at ibm_washington (127-qubits quantum machine) calibration file and I saw it contains a set of attributes (see below). I have some doubt about their meaning and I would really appreciate if somebody could give me a glimpse of what does represent each of them. Thanks.
T1 (us),
T2 (us),
Frequency (GHz),
Anharmonicity (GHz),
Readout assignment error,
Prob meas0 prep1,
Prob meas1 prep0,
Readout length (ns),
ID error,
√x (sx) error
Single-qubit Pauli-X error
CNOT error
Gate time (ns)
Related
I'm following along with The Audio Programming Book by Richard Boulanger. In Chapter two we create several basic audio rate oscillators using C and the standard libraries to generate simple WAV files.
Both my implementation and the book's code exhibit a strange issue:
I am able to generate a simple sine wave using sin() (from math.h), but noticed the playback has a bit of static. Upon investigation I noticed that occasionally, some of the audio frames at peak amplitude are getting "flipped" to a negative value.
To debug this situation, I'm outputting the values of the audio frames generated to stdout and this flipping behavior lines up with the peak value of 0.999999.
When I scale the output by 0.99 this problem disappears. What's going on?
Looking at siggen.c I was able to find the real problem has to do with the maximum value conversion to short datatype:
portsf.c:78
#define MAX_16BIT (32768.0)
portsf.c:1618
ssamp = (short) psf_round(fsamp * MAX_16BIT);
When we have a float sample near 1.0 this results in the conversion (short)(32768). Given that a short can only hold up to 32767 the value gets wrapped to the smallest short possible, -32768.
To fix this, I suggest modifying line 1618 to instead read:
ssamp = (short) psf_round(fsamp * 32767.0);
This will reduce the peak-to-peak value range by 1, but well worth avoiding this problem in my opinion
This question will be useful to many.
Can we collate a list of challenges in enabling Practical-Scale Quantum Computing?
Nathan Aw
The challenges are dependent on the physical architecture. Pick a physical implementation and look for which of the DiVincenzo's criterias are missing. These would be the chosen architecture's challenges.
First of all, I should mention that when people say they want a practical-scale quantum computer, what they probably mean is that they want a device that could perform a computation and yield a good result with a probability arbitrarily close to 100%. This can be achieved with imperfect qubits by using Quantum-Error-Correction algorithms, but it still requires somewhat decent quality qubits (and "decent" by today's standards is of the highest quality people do). There's a qubit quality threshold above which using those error correction algorithms becomes useful and reduces the logical error rate. Below that threshold, it is best to hope for no errors and not perform any error correction.
To answer the question:
""Are there physical implementations that fulfill the 5 DiVincenzo's criteria?""
Some architectures partially fulfill all of them, but not to the level needed to perform error correction & therefore enable practical-scale and reliable quantum computing. For example, IBM and Rigetti-computing (maybe google too? to be verified) have small-scale quantum computers using superconducting/circuit qubits, but each individual qubit is not that great (by error correction standards) and several of the qubits features are below Quantum-Error-Correction threshold. This means that performing a computation could yield an incorrect result. The probability to get a wrong result depends on a bunch of factors such as the coherence time of each of the individual qubits, single and 2-qubit gates fidelities, readout fidelity, etc.
Such a small-scale quantum computer does perform, in a sense, quantum computing. It is just not yet at the required reliability to do interesting applications in quantum chemistry or condensed matter (which are expected to be the killer-apps of a quantum computer).
I interfaced RDM6300 RFID module with 16F877A PIC. But It seems does not work although I connected it properly. I followed this Tutorial correctly. So need to know whether this RDM6300 support for this task and if yes, Are there any changes I need to do other than the VCC, GND and TX. (I put those pins according to the RDM6300 datasheet). Can anyone give me a better solution or the tutorial link.
I'm using
MPLAB XC8 Code.
Welcome to the world of low level :)
First try to minimize the number of unknowns. In your case it looks like it's your first time with RDM6300 and the PIC chip, so try connecting either to your PC (with appropriate serial<->TTL level shifter) to confirm serial interfaces on both work properly and with correct baud rate.
Then connect them together.
When something doesn't work you'll need to investigate a bit. A voltmeter is a must, so you can at least check the power supplies are correct. A logical analyser or oscilloscope would be great, as you could check what (if any) signal is being transferred on data lines.
Hopefully this provides some starting pointers.
When you encounter an issue you can't solve, simplify it into the smallest possible issue with the error you see, and then ask a question - you'll have much greater chance of a useful answer. Often just doing this will make you realise what the problem is before even asking for help.
This question already has an answer here:
How to generate the audio spectrum using fft in C++? [closed]
(1 answer)
Closed 9 years ago.
How would I go about implementing a spectrum analyser like the ones in WinAmp below?
Just by looking at it, I think that these bars are rendered to display the 'volume level' of a specific frequency band of the incoming audio data; however, I'm not sure how to actually calculate this data needed for the rather easy task of drawing the bars.
From what I've been told and understand, calculating these values can be done by using an FFT — however, I'm not exactly sure how to calculate those, given a buffer of input data — am I on the right track about FFTs? How would I apply an FFT on the input data and get, say, an integer out of the FFT that represents the 'volume' of a specific frequency band?
The drawing part isn't a problem, since I can just draw directly to my framebuffer and render that out. I'm doing this as a project on an FPGA, using a Nios II soft-CPU, in case anyone's wondering about potential hardware limitations. Audio data comes in as 24-bit data at 96kHz.
You're probably looking for FFTw.
edit:
To elaborate on your question:
calculating these values can be done by using an FFT — however, I'm not exactly sure how to calculate those, given a buffer of input data: yes, you're right; that's exactly how it's done. You take a (necssarily small, due to the time-frequency uncertainty principle) sample segment out of the currently playing audio data, and feed it to a (typically) discrete, real-only FFT (one of the best known, most widely used and fastest being the DCT family of DFTs - in fact there are highly optimized versions of most DCTs in FFTw). Then you take out the next sample segment and repeat the process.
The output of the FFT will be the freqeuncy decomposition of the audio signal that has been fed in - you then need to decide how to display it (i.e. which function to use on the outputs of the FFT, common candidates being f(x) = x; f(x) = sqrt(x); f(x) = log(x)) and also how to present/animate the following readings (e.g. you could average each band in the temporal direction or you could have the maximums "fall off" slowly).
rage-edit:
Additional links since it appears somebody knows how to downvote but not how to use google:
http://en.wikipedia.org/wiki/FFTW
http://webcache.googleusercontent.com/search?q=cache:m6ou54tn_soJ:www.fftw.org/+&cd=1&hl=en&ct=clnk&gl=it&client=firefox-a
http://web.archive.org/web/20130123131356/http://fftw.org/
It's pretty straight forward - just use one of the many FFT algorithms! Most of them require floating point calculations, but a google search brings up methods with just integers. You are spot on though, FFT's are what you want.
http://en.wikipedia.org/wiki/Fast_Fourier_transform
To understand how to apply a FFT, you should have a read of this page on discrete fourier transforms, although it's quite heavy on maths:
http://en.wikipedia.org/wiki/Discrete_Fourier_transform
To implement it on your FPGA, I'd have a look at the source code of this project:
http://qt-project.org/doc/qt-4.8/demos-spectrum.html
Here's a previous SO question that gives a summary of how it works (in any language).
How to generate the audio spectrum using fft in C++?
There's an immense amount of information on creating what by the way is called a "Spectrum Analyser", there must be dozens of complete implementations where the source code is freely available. Just page through a google search for "Spectrum analyser source code C" for example.
Recently I asked this question: How to get the fundamental frequency from FFT? (you don't actually need to read it)
My doubt right now it: how to use the cepstral algorithm?
I just don't know how to use it because the only language that I know is ActionScript 3, and for this reason I have few references about the native functions found in C, Java and so on, and how I should implement them on AS. Most articles are about these languages =/
(althought, answers in other languages than AS are welcome, just explain how the script works please)
The articles I found about cepstral to find the fundamental frequency of a FFT result told me that I should do this:
signal → FT → abs() → square → log → FT → abs() → square → power cepstrum
mathematically:
|F{log(|F{f(t)}|²)}|²
Important info:
I am developing a GUITAR TUNER in flash
This is the first time I am dealing with advanced sound
I am using an FFT to extract frequency bins from the signal that reaches user's microphone, but I got stuck in getting the fundamental frequency from it
I don't know:
How to apply a square in an ARRAY (I mean, the data that my FFT gives me is an array. Should I multiply it by itself? ActionScript's debug throws errors when I try to fftResults * fftResults)
How to apply the "log". I would not know how to apply it even if I had a single number.
What is the difference between complex cepstral and power cepstral. Also, what of them should I use? I am trying to develop a guitar tuner.
Thanks!
Note that the output of an FFT is an array of complex values, i.e. each bin = re + j*im. I think you can just combine the abs and square operations and calculate re*re + im*im for each bin. This gives you a single positive value for each bin, and obviously you can calculate the log value for each bin quite easily. You then need to do a second FFT on this log squared data and again using the output of this second FFT you will calculate re*re + im*im for each bin. You will then have an array of postive values which will have one or more peaks representing the fundamental frequency or frequencies of your input.
The autocorrelation is the easiest and most logical approach, and the best place to start.
To get this working, start with a simple autocorrelation, and then, if necessary, improve it following the outline provided by YIN. (YIN is based on the autocorrelation with refinements. But whether or not you'll need these refinements depends on details of your situation.) This way also, you can learn as you go rather than trying to understand the whole thing in one shot.
Although FFT approaches can also work, they are a bit more confusing. The issue is that what you are really after is the period, and this isn't well represented by the FFT. The missing fundamental is a good example of this, where if you have 2Hz and 3Hz, the fundamental is 1Hz, but is nowhere in the FFT, while 1Hz is obvious in a time based representation (e.g. the autocorrelation). Add to this that overtones aren't necessarily harmonic, and noise, etc... and all of these issues make it usually best to start with a direct approach to the problem.
There are many ways of finding fundamental frequency (F0).
For languages like Java etc there are many libraries with those type of algorithms already implemented (you can study their sources).
MFCC (based on cepstral) implemented in Comirva (Open source).
Audacity (beta version!) (Open source) presents cepstrum, autocorellation, enhanced autocorellation,
Yin based on autocorrelation (example )
Finding max signal values after FFT
All these algorithms may be be very helpful for you. However easiest way to get F0 (one value in Hz) would be to use Yin.