/// <summary> /// Execute the given <code>qasmExe.code</code> launching <code>qasmExe.shots</code> executions. /// When the result is ready, the <code>onExecuted</code> callback will be called. /// The <see cref="OnExecuted"/> will recieve <see cref="QASMExecutionResult"/> /// with the accumulated result. /// </summary> /// <param name="qasmExe">Executable configuration</param> /// <param name="onExecuted">The callback called when execution ends</param> public void ExecuteCode(QASMExecutable qasmExe, OnExecuted onExecuted) { // Request is not needed yet, see "ExecuteCodeRawResult" implementation in case of future changes GenericExecution(qasmExe, useMemory: false, (jsonResult) => { onExecuted(ReadCountJSON(jsonResult)); }); }
//public delegate void OnRandomGenerated<T>(T generated); //public delegate void OnRandomPoolGenerated<T>(List<T> pool); #region Single Value Generation Methods /// <summary> /// Generates a true random boolean. /// It makes an asynchronous operation so the value is returned through /// the callback <see cref="OnRandomBoolGenerated"/> /// </summary> /// <param name="onRandomBoolGenerated">The callback called when the bool is available</param> public void GenerateBool(Action <bool> onRandomBoolGenerated) { // For bool values should be an even number of shots QASMExecutable qasmExe = new QASMExecutable(_qasmSingleBoolCode, 15); executionSession.ExecuteCode(qasmExe, (response) => { onRandomBoolGenerated(response.maxKey == 1); }); }
private void GenericExecution(QASMExecutable qasmExe, bool useMemory, OnJsonResult onJsonResult) { // API request List <IMultipartFormSection> formData = new List <IMultipartFormSection> { // QASM parameter new MultipartFormDataSection("qasm", qasmExe.code), new MultipartFormDataSection("memory", useMemory ? "True" : "False") }; // Api token parameter if (apiTokenString == "" && API_TOKEN_STRING_REQUIRED) { throw new System.Exception("API Token is required to run QASM"); } if (apiTokenString != "") { formData.Add(new MultipartFormDataSection("api_token", apiTokenString)); } // Number of shots if (qasmExe.useShots) { formData.Add(new MultipartFormDataSection("shots", $"{qasmExe.shots}")); } // Request UnityWebRequest www = UnityWebRequest.Post(server + "/api/run/qasm", formData); www.SendWebRequest().completed += (_) => { #if UNITY_EDITOR if (verbose) { Debug.Log("text: " + www.downloadHandler.text); } #endif if (www.responseCode == 200) // Is OK { onJsonResult(GetResultJSON(www.downloadHandler.text)); } else // ON ERROR { string responseCodeMessage = $"Response Code: {www.responseCode}"; if (www.responseCode == 500) { responseCodeMessage += " - Internal server error."; if (!string.IsNullOrEmpty(apiTokenString)) { responseCodeMessage += "\nIf you are using simulator, consider not to use apiTokenString."; } } Debug.LogError(responseCodeMessage); throw new System.Exception(responseCodeMessage); } }; }
/// <summary> /// Generates a pool of <paramref name="count"/> true random booleans. /// It makes an asynchronous operation so the value is returned through /// the callback <see cref="OnRandomBoolPoolGenerated"/>. /// </summary> /// <param name="count">The amount of booleans generated</param> /// <param name="onRandomBoolPoolGenerated">The callback called when the pool is available</param> public void GenerateBoolPool(int count, Action <List <bool> > onRandomBoolPoolGenerated) { QASMExecutable qasmExe = new QASMExecutable(_qasmSingleBoolCode, count); executionSession.ExecuteCodeRawResult(qasmExe, (response) => { List <bool> pool = new List <bool>(); for (int i = 0; i < response.rawResult.Count; i++) { pool.Add(response.rawResult[i] == 1); } onRandomBoolPoolGenerated(pool); }); }
/// <summary> /// Execute the given <code>qasmExe.code</code> launching <code>qasmExe.shots</code> executions. /// When the result is ready, the <code>onExecuted</code> callback will be called. /// The <see cref="OnExecuted"/> will recieve <see cref="QASMExecutionResult"/> /// with the per shot results as rawResult. /// If the backends does not supports memory feature, the raw result will be simulated with /// accumulated results. /// </summary> /// <param name="qasmExe">Executable configuration</param> /// <param name="onExecuted">The callback called when execution ends</param> public void ExecuteCodeRawResult(QASMExecutable qasmExe, OnExecuted onExecuted) { RequestBackendConfig((_) => { GenericExecution(qasmExe, useMemory: _backendConfig.supportsMemory, (jsonResult) => { if (_backendConfig.supportsMemory) { onExecuted(ReadRawDataJSON(jsonResult)); } else { QASMExecutionResult result = ReadCountJSON(jsonResult); result.SimulateRawResult(); onExecuted(result); } }); }); }
/// <summary> /// Generates a true random int of n <paramref name="bits"/>. /// It makes an asynchronous operation so the value is returned through /// the callback <see cref="OnRandomIntGenerated"/> /// </summary> /// <param name="bits">The number of bits used to generate the int</param> /// <param name="onRandomFloatGenerated">The callback called when the int is available</param> public void GenerateIntNbits(int bits, Action <int> onRandomIntGenerated) { executionSession.RequestBackendConfig((backendConfig) => { int codeRegs = Mathf.Min(backendConfig.qubitsCount, bits); int shotsNeeded = Mathf.CeilToInt((float)bits / codeRegs); QASMExecutable qasmExe = new QASMExecutable(RandomNRegisterCode(codeRegs), shotsNeeded); executionSession.ExecuteCodeRawResult(qasmExe, (response) => { int rng = 0; for (int i = 0; i < response.rawResult.Count; i++) { rng += response.rawResult[i] << (i * codeRegs); } rng = ClampToBits(rng, bits); onRandomIntGenerated(rng); }); }); }
/// <summary> /// Generates a pool of <paramref name="count"/> true random ints of n <paramref name="bits"/>. /// It makes an asynchronous operation so the value is returned through /// the callback <see cref="OnRandomFloatPoolGenerated"/>. /// </summary> /// <param name="bits">The number of bits used to generate the int</param> /// <param name="count">The amount of ints generated</param> /// <param name="onRandomIntPoolGenerated">The callback called when the pool is available</param> public void GenerateIntNbitsPool(int bits, int count, Action <List <int> > onRandomIntPoolGenerated) { executionSession.RequestBackendConfig((backendConfig) => { int codeRegs = Mathf.Min(backendConfig.qubitsCount, bits); int shotsNeededPerItem = Mathf.CeilToInt((float)bits / codeRegs); QASMExecutable qasmExe = new QASMExecutable(RandomNRegisterCode(codeRegs), shotsNeededPerItem * count); executionSession.ExecuteCodeRawResult(qasmExe, (response) => { List <int> pool = new List <int>(); for (int i = 0; i < count; i++) { int rng = 0; int padding = i * shotsNeededPerItem; for (int j = 0; j < shotsNeededPerItem; j++) { rng += response.rawResult[j + padding] << (j * codeRegs); } rng = ClampToBits(rng, bits); pool.Add(rng); } onRandomIntPoolGenerated(pool); }); }); }