public void NonNullConstructionAndConversion()
{
string x = new string('x', 1);
NonNullable<string> subject = new NonNullable<string>(x);
Assert.AreSame(x, (string)subject);
Assert.AreSame(x, subject.Value);
}
public void DefaultConstructionAndImplicitConversion()
{
NonNullable<string> x = new NonNullable<string>();
try
{
string y = x;
Assert.Fail("Expected exception:" + y);
}
catch (NullReferenceException)
{
// Expected
}
}
public void DefaultConstructionAndValueProperty()
{
NonNullable<string> x = new NonNullable<string>();
try
{
string y = x.Value;
Assert.Fail("Expected exception:" + y);
}
catch (NullReferenceException)
{
// Expected
}
}
public static NonNullable <T> Create <T>(NonNullable <T> Value) => new NonNullable <T>(Value);
NonNullable <string> SourceOr(NonNullable <string> origSource) => NonNullable <string> .New(source ?? origSource.Value);
private static void SampleMethod(NonNullable<string> text)
{
// Shouldn't get here with usual conversions, but could do
// through default construction. The conversion to string
// will throw an exception anyway, so we're guaranteed
// that foo is non-null afterwards.
string foo = text;
Assert.IsNotNull(foo);
}
// interface methods
public bool Transformation(QsCompilation compilation, out QsCompilation transformed)
{
transformed = FilterSourceFiles.Apply(compilation);
var manager = new CompilationUnitManager();
// get source code from examples
var fileManagers = ExamplesInDocs.Extract(transformed)
.Select(g => InitializeFileManager(g, compilation, g.Key))
.Where(m => m != null).ToImmutableHashSet();
manager.AddOrUpdateSourceFilesAsync(fileManagers, suppressVerification: true);
var sourceFiles = fileManagers.Select(m => m.FileName).ToImmutableHashSet();
bool IsGeneratedSourceFile(NonNullable <string> source) => sourceFiles.Contains(source);
// get everything contained in the compilation as references
var refName = NonNullable <string> .New(Path.GetFullPath(ReferenceSource));
var refHeaders = new References.Headers(refName, DllToQs.Rename(compilation).Namespaces);
var refDict = new Dictionary <NonNullable <string>, References.Headers> {
{ refName, refHeaders }
};
var references = new References(refDict.ToImmutableDictionary());
manager.UpdateReferencesAsync(references);
// compile the examples in the doc comments and add any diagnostics to the list of generated diagnostics
var built = manager.Build();
var diagnostics = built.Diagnostics();
this.Diagnostics.AddRange(diagnostics.Select(d => IRewriteStep.Diagnostic.Create(d, IRewriteStep.Stage.Transformation)));
if (diagnostics.Any(d => d.Severity == VS.DiagnosticSeverity.Error))
{
return(false);
}
// add the extracted namespace elements from doc comments to the transformed compilation
var toBeAdded = built.BuiltCompilation.Namespaces.ToImmutableDictionary(
ns => ns.Name,
ns => FilterBySourceFile.Apply(ns, IsGeneratedSourceFile));
var namespaces = compilation.Namespaces.Select(ns =>
toBeAdded.TryGetValue(ns.Name, out var add)
? new QsNamespace(ns.Name, ns.Elements.AddRange(add.Elements), ns.Documentation)
: ns);
var addedNamespaces = toBeAdded.Values.Where(add => !compilation.Namespaces.Any(ns => ns.Name.Value == add.Name.Value));
transformed = new QsCompilation(namespaces.Concat(addedNamespaces).ToImmutableArray(), compilation.EntryPoints);
// mark all newly created callables that take unit as argument as unit tests to run on the QuantumSimulator and ResourcesEstimator
bool IsSuitableForUnitTest(QsCallable c) => IsGeneratedSourceFile(c.SourceFile) && c.Signature.ArgumentType.Resolution.IsUnitType;
var qsimAtt = AttributeUtils.BuildAttribute(BuiltIn.Test.FullName, AttributeUtils.StringArgument(Constants.QuantumSimulator));
var restAtt = AttributeUtils.BuildAttribute(BuiltIn.Test.FullName, AttributeUtils.StringArgument(Constants.ResourcesEstimator));
transformed = AttributeUtils.AddToCallables(transformed, (qsimAtt, IsSuitableForUnitTest), (restAtt, IsSuitableForUnitTest));
return(true);
}
// utils for getting the necessary information for editor commands
/// <summary>
/// Throws an ArgumentNullException if the given offset or relative range is null.
/// </summary>
internal static Location AsLocation(NonNullable <string> source,
Tuple <int, int> offset, Tuple <QsPositionInfo, QsPositionInfo> relRange) =>
/// <summary>
/// Builds the corresponding .net core assembly from the Q# syntax tree.
/// </summary>
public static AssemblyInfo BuildAssembly(Uri[] fileNames, QsCompiler.SyntaxTree.QsNamespace[] syntaxTree, IEnumerable <MetadataReference> references, QSharpLogger logger, string targetDll)
{
if (logger.HasErrors)
{
return(null);
}
logger.LogDebug($"Compiling the following Q# files: {string.Join(",", fileNames.Select(f => f.LocalPath))}");
try
{
// Generate C# simulation code from Q# syntax tree and convert it into C# syntax trees:
var trees = new List <SyntaxTree>();
NonNullable <string> GetFileId(Uri uri) => CompilationUnitManager.TryGetFileId(uri, out var id) ? id : NonNullable <string> .New(uri.AbsolutePath);
foreach (var file in fileNames)
{
var sourceFile = GetFileId(file);
var code = SimulationCode.generate(sourceFile, syntaxTree);
var tree = CSharpSyntaxTree.ParseText(code, encoding: UTF8Encoding.UTF8);
trees.Add(tree);
logger.LogDebug($"Generated the following C# code for {sourceFile.Value}:\n=============\n{code}\n=============\n");
}
// Compile the C# syntax trees:
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Debug);
var compilation = CSharpCompilation.Create(
Path.GetFileNameWithoutExtension(targetDll),
trees,
references,
options);
// Generate the assembly from the C# compilation:
using (var ms = new MemoryStream())
{
EmitResult result = compilation.Emit(ms);
if (!result.Success)
{
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
logger.LogError("IQS000", "Could not compile Roslyn dll from working folder.");
foreach (Diagnostic diagnostic in failures)
{
logger.LogError(diagnostic.Id, diagnostic.GetMessage());
}
return(null);
}
else
{
logger.LogDebug($"Assembly successfully generated. Caching at {targetDll}.");
var data = ms.ToArray();
try
{
File.WriteAllBytes(targetDll, data);
}
catch (Exception e)
{
logger.LogError("IQS001", $"Unable to save assembly cache: {e.Message}.");
}
return(new AssemblyInfo(Assembly.Load(data), targetDll, syntaxTree));
}
}
}
catch (Exception e)
{
logger.LogError("IQS002", $"Unexpected error compiling assembly: {e.Message}.");
return(null);
}
}
public static byte[] KeyFromPassword(NonNullable <byte[]> password, HashAlgorithmName algorithm, byte[] salt = null, int iterations = DefaultIterations, int keyLength = DefaultKeyLength)
{
salt ??= SaltBytes();
using var keyGen = new Rfc2898DeriveBytes(password, salt, iterations, algorithm);
return(keyGen.GetBytes(keyLength));
}
/// <summary>
/// Adds a key/value pair to the dictionary.
/// </summary>
/// <typeparam name="TK">key type</typeparam>
/// <typeparam name="TV">value type</typeparam>
/// <param name="dictionary"></param>
/// <param name="key"></param>
/// <param name="addFunc">add function</param>
/// <param name="updateFunc">update function</param>
/// <returns>The new value for the key.</returns>
/// <remarks>
/// Add or updates the key/value pair to the dictionary.
/// </remarks>
private static TV AddOrUpdateInternal <TK, TV>(IDictionary <TK, TV> dictionary, TK key, NonNullable <Func <TK, TV> > addFunc, NonNullable <Func <TK, TV, TV> > updateFunc)
{
dictionary[key] = !dictionary.ContainsKey(key)
? addFunc.Value.Invoke(key)
: updateFunc.Value.Invoke(key, dictionary[key]);
return(dictionary[key]);
}
public void Constructor_ConstructViaConstructor_NonNullReference()
{
NonNullable<string> str = new NonNullable<string>("abc");
Assert.AreEqual(str.Value, "abc");
}
/// <summary>
/// Builds the corresponding .net core assembly from the Q# syntax tree.
/// </summary>
private AssemblyInfo BuildAssembly(ImmutableDictionary <Uri, string> sources, CompilerMetadata metadata, QSharpLogger logger, string dllName)
{
logger.LogDebug($"Compiling the following Q# files: {string.Join(",", sources.Keys.Select(f => f.LocalPath))}");
var qsCompilation = this.UpdateCompilation(sources, metadata.QsMetadatas, logger);
if (logger.HasErrors)
{
return(null);
}
try
{
// Generate C# simulation code from Q# syntax tree and convert it into C# syntax trees:
var trees = new List <SyntaxTree>();
NonNullable <string> GetFileId(Uri uri) => CompilationUnitManager.TryGetFileId(uri, out var id) ? id : NonNullable <string> .New(uri.AbsolutePath);
foreach (var file in sources.Keys)
{
var sourceFile = GetFileId(file);
var code = SimulationCode.generate(sourceFile, CodegenContext.Create(qsCompilation.Namespaces));
var tree = CSharpSyntaxTree.ParseText(code, encoding: UTF8Encoding.UTF8);
trees.Add(tree);
logger.LogDebug($"Generated the following C# code for {sourceFile.Value}:\n=============\n{code}\n=============\n");
}
// Compile the C# syntax trees:
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Debug);
var compilation = CSharpCompilation.Create(
Path.GetFileNameWithoutExtension(dllName),
trees,
metadata.RoslynMetadatas,
options);
// Generate the assembly from the C# compilation:
using (var ms = new MemoryStream())
using (var bsonStream = new MemoryStream())
{
using var writer = new BsonDataWriter(bsonStream)
{
CloseOutput = false
};
var fromSources = qsCompilation.Namespaces.Select(ns => FilterBySourceFile.Apply(ns, s => s.Value.EndsWith(".qs")));
Json.Serializer.Serialize(writer, new QsCompilation(fromSources.ToImmutableArray(), qsCompilation.EntryPoints));
var resourceDescription = new ResourceDescription
(
resourceName: QsCompiler.ReservedKeywords.DotnetCoreDll.ResourceName,
dataProvider: () => new MemoryStream(bsonStream.ToArray()),
isPublic: true
);
var result = compilation.Emit(ms, manifestResources: new[] { resourceDescription });
if (!result.Success)
{
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
logger.LogError("IQS000", "Could not compile Roslyn dll from working folder.");
foreach (Diagnostic diagnostic in failures)
{
logger.LogError(diagnostic.Id, diagnostic.GetMessage());
}
return(null);
}
else
{
logger.LogDebug($"Assembly successfully generated. Caching at {dllName}.");
var data = ms.ToArray();
try
{
File.WriteAllBytes(dllName, data);
}
catch (Exception e)
{
logger.LogError("IQS001", $"Unable to save assembly cache: {e.Message}.");
}
return(new AssemblyInfo(Assembly.Load(data), dllName, fromSources.ToArray()));
}
}
}
catch (Exception e)
{
logger.LogError("IQS002", $"Unexpected error compiling assembly: {e.Message}.");
return(null);
}
}
public BaseUrls(IConfiguration config)
{
_baseUrl = new NonNullable <string>(value: config["BaseUrl"], paramName: "config.BaseUrl");
_imageBaseUrl = new NonNullable <string>(value: config["ImageBaseUrl"], paramName: "config.ImageBaseUrl");
}
internal static QsQualifiedName MakeFullName(string name)
{
return(new QsQualifiedName(CanonName, NonNullable <string> .New(name)));
}
public override NonNullable <string> OnSourceFile(NonNullable <string> f)
{
this.SharedState.SourceFiles.Add(f);
return(base.OnSourceFile(f));
}
public void NonNullable_GetUnderlyingType_WithNullType_ThrowsError()
{
Type type = null;
Assert.Throws <ArgumentNullException>(() => NonNullable.GetUnderlyingType(type), "Value cannot be null.\nParameter name: nonNullableType");
}
public void ToString_ReturnsUnderlyingToString()
{
string str = "abc";
NonNullable<string> str2 = new NonNullable<string>(str);
Assert.AreEqual(str2.ToString(), str);
}
public static NonNullable <T> Create <T>(T Value, NonNullable <T> Null) => new NonNullable <T>(Value, Null);
public void Constructor_DefaultConstructorCausesExceptionWhenCast()
{
NonNullable<string> str = new NonNullable<string>();
string str2 = str;
}
public override NonNullable <string> onSourceFile(NonNullable <string> f)
{
this._Scope.Source = f;
return(base.onSourceFile(f));
}
public static byte[] KeyFromPassword(NonNullable <byte[]> password, byte[] salt = null, int iterations = DefaultIterations, int keyLength = DefaultKeyLength) => KeyFromPassword(password, HashAlgorithmName.SHA512, salt, iterations, keyLength);
public void ExcludeInaccessible()
{
var elements =
new[] { AccessModifier.DefaultAccess, AccessModifier.Internal }
.SelectMany(access =>
{
var source = NonNullable <string> .New("Tests.qs");
var unit = ResolvedType.New(QsType.UnitType);
var signature = new ResolvedSignature(Array.Empty <QsLocalSymbol>().ToImmutableArray(),
unit,
unit,
CallableInformation.NoInformation);
var argumentTuple = QsTuple <ArgDeclType> .NewQsTuple(ImmutableArray.Create <QsTuple <ArgDeclType> >());
var callable = new QsCallable(kind: QsCallableKind.Operation,
fullName: MakeFullName(access + "Operation"),
attributes: ImmutableArray <QsDeclarationAttribute> .Empty,
modifiers: new Modifiers(access),
sourceFile: source,
location: ZeroLocation,
signature: signature,
argumentTuple: argumentTuple,
specializations: ImmutableArray.Create <QsSpecialization>(),
documentation: ImmutableArray.Create <string>(),
comments: QsComments.Empty);
var typeItems = QsTuple <QsTypeItem> .NewQsTuple(
ImmutableArray.Create(QsTuple <QsTypeItem> .NewQsTupleItem(QsTypeItem.NewAnonymous(unit))));
var type = new QsCustomType(fullName: MakeFullName(access + "Type"),
attributes: ImmutableArray <QsDeclarationAttribute> .Empty,
modifiers: new Modifiers(access),
sourceFile: source,
location: ZeroLocation,
type: unit,
typeItems: typeItems,
documentation: ImmutableArray.Create <string>(),
comments: QsComments.Empty);
return(new[]
{
QsNamespaceElement.NewQsCallable(callable),
QsNamespaceElement.NewQsCustomType(type)
});
});
var emptyLookup = Array.Empty <ImmutableArray <string> >().ToLookup(x => NonNullable <string> .New(""));
var ns = new QsNamespace(CanonName, elements.ToImmutableArray(), emptyLookup);
var docNs = new DocNamespace(ns);
var stream = new MemoryStream();
docNs.WriteToStream(stream, null);
var expected = @"### YamlMime:QSharpNamespace
# This file is automatically generated.
# Please do not modify this file manually, or your changes may be lost when
# documentation is rebuilt.
uid: microsoft.quantum.canon
name: Microsoft.Quantum.Canon
operations:
- uid: microsoft.quantum.canon.defaultaccessoperation
summary: ''
newtypes:
- uid: microsoft.quantum.canon.defaultaccesstype
summary: ''
...
";
var actual = Encoding.UTF8.GetString(stream.ToArray());
Assert.Equal(expected, actual);
}
/// <summary> /// Helper function that returns true if the given file id is consistent with the one for a code snippet. /// </summary> public static bool IsCodeSnippet(NonNullable <string> fileId) => fileId.Value == SNIPPET_FILE_ID.Value;
public LocationDef(NonNullable <Coordinate> Region, NonNullable <Coordinate> sector)
{
this.Region = Region;
this.Sector = sector;
}
private static Identifier GetConcreteIdentifier(
Response currentResponse,
Stack <Request> requests,
List <Response> responses,
Identifier.GlobalCallable globalCallable,
ImmutableConcretion types)
{
QsQualifiedName concreteName = globalCallable.Item;
var typesHashSet = ImmutableHashSet <KeyValuePair <Tuple <QsQualifiedName, NonNullable <string> >, ResolvedType> > .Empty;
if (types != null && !types.IsEmpty)
{
typesHashSet = types.ToImmutableHashSet();
}
string name = null;
// Check for recursive call
if (currentResponse.originalName.Equals(globalCallable.Item) &&
typesHashSet.SetEquals(currentResponse.typeResolutions))
{
name = currentResponse.concreteCallable.FullName.Name.Value;
}
// Search requests for identifier
if (name == null)
{
name = requests
.Where(req =>
req.originalName.Equals(globalCallable.Item) &&
typesHashSet.SetEquals(req.typeResolutions))
.Select(req => req.concreteName.Name.Value)
.FirstOrDefault();
}
// Search responses for identifier
if (name == null)
{
name = responses
.Where(res =>
res.originalName.Equals(globalCallable.Item) &&
typesHashSet.SetEquals(res.typeResolutions))
.Select(res => res.concreteCallable.FullName.Name.Value)
.FirstOrDefault();
}
// If identifier can't be found, make a new request
if (name == null)
{
// If this is not a generic, do not change the name
if (!typesHashSet.IsEmpty)
{
// Create new name
name = "_" + Guid.NewGuid().ToString("N") + "_" + globalCallable.Item.Name.Value;
concreteName = new QsQualifiedName(globalCallable.Item.Namespace, NonNullable <string> .New(name));
}
requests.Push(new Request()
{
originalName = globalCallable.Item,
typeResolutions = types,
concreteName = concreteName
});
}
else // If the identifier was found, update with the name
{
concreteName = new QsQualifiedName(globalCallable.Item.Namespace, NonNullable <string> .New(name));
}
return(Identifier.NewGlobalCallable(concreteName));
}
/// <summary>
/// LogEventWriter constructor.
/// </summary>
/// <param name="category">log category</param>
/// <param name="logEventListener">log event listener</param>
public LogEventWriter(NonNullable <string> category, Action <LogEventMessage> logEventListener)
: this(category, new LogEventReceiver(logEventListener))
{
}
internal bool IsRelevant(NonNullable <string> source) => this.RelevantSourseFiles?.Contains(source) ?? true;
public void ParseOp()
{
ArgDeclType BuildArgument(string name, ResolvedType t)
{
var validName = QsLocalSymbol.NewValidName(NonNullable <string> .New(name));
var info = new InferredExpressionInformation(false, false);
return(new ArgDeclType(validName, t, info, QsNullable <Tuple <int, int> > .Null, EmptyRange));
}
string[] comments =
{
"# Summary",
"Convenience function that performs state preparation by applying a ",
"`statePrepUnitary` on the input state, followed by adiabatic state ",
"preparation using a `adiabaticUnitary`, and finally phase estimation ",
"with respect to `qpeUnitary`on the resulting state using a ",
"`phaseEstAlgorithm`.",
"",
"# Input",
"## statePrepUnitary",
"An oracle representing state preparation for the initial dynamical",
"generator.",
"## adiabaticUnitary",
"An oracle representing the adiabatic evolution algorithm to be used",
"to implement the sweeps to the final state of the algorithm.",
"## qpeUnitary",
"An oracle representing a unitary operator $U$ representing evolution",
"for time $\\delta t$ under a dynamical generator with ground state",
"$\\ket{\\phi}$ and ground state energy $E = \\phi\\\\,\\delta t$.",
"## phaseEstAlgorithm",
"An operation that performs phase estimation on a given unitary operation.",
"See [iterative phase estimation](/quantum/libraries/characterization#iterative-phase-estimation)",
"for more details.",
"## qubits",
"A register of qubits to be used to perform the simulation.",
"",
"# Output",
"An estimate $\\hat{\\phi}$ of the ground state energy $\\phi$",
"of the generator represented by $U$."
};
string expected = @"### YamlMime:QSharpType
uid: microsoft.quantum.canon.adiabaticstateenergyunitary
name: AdiabaticStateEnergyUnitary
type: operation
namespace: Microsoft.Quantum.Canon
summary: |-
Convenience function that performs state preparation by applying a
`statePrepUnitary` on the input state, followed by adiabatic state
preparation using a `adiabaticUnitary`, and finally phase estimation
with respect to `qpeUnitary`on the resulting state using a
`phaseEstAlgorithm`.
syntax: 'operation AdiabaticStateEnergyUnitary (statePrepUnitary : (Qubit[] => Unit), adiabaticUnitary : (Qubit[] => Unit), qpeUnitary : (Qubit[] => Unit is Adj + Ctl), phaseEstAlgorithm : ((Microsoft.Quantum.Canon.DiscreteOracle, Qubit[]) => Double), qubits : Qubit[]) : Double'
input:
content: '(statePrepUnitary : (Qubit[] => Unit), adiabaticUnitary : (Qubit[] => Unit), qpeUnitary : (Qubit[] => Unit is Adj + Ctl), phaseEstAlgorithm : ((Microsoft.Quantum.Canon.DiscreteOracle, Qubit[]) => Double), qubits : Qubit[])'
types:
- name: statePrepUnitary
summary: |-
An oracle representing state preparation for the initial dynamical
generator.
isOperation: true
input:
types:
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Unit
- name: adiabaticUnitary
summary: |-
An oracle representing the adiabatic evolution algorithm to be used
to implement the sweeps to the final state of the algorithm.
isOperation: true
input:
types:
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Unit
- name: qpeUnitary
summary: |-
An oracle representing a unitary operator $U$ representing evolution
for time $\delta t$ under a dynamical generator with ground state
$\ket{\phi}$ and ground state energy $E = \phi\\,\delta t$.
isOperation: true
input:
types:
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Unit
functors:
- Adjoint
- Controlled
- name: phaseEstAlgorithm
summary: |-
An operation that performs phase estimation on a given unitary operation.
See [iterative phase estimation](/quantum/libraries/characterization#iterative-phase-estimation)
for more details.
isOperation: true
input:
types:
- uid: microsoft.quantum.canon.discreteoracle
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Double
- name: qubits
summary: A register of qubits to be used to perform the simulation.
isArray: true
isPrimitive: true
uid: Qubit
output:
content: Double
types:
- summary: |-
An estimate $\hat{\phi}$ of the ground state energy $\phi$
of the generator represented by $U$.
isPrimitive: true
uid: Double
...
";
var qubitArrayType = ResolvedType.New(QsType.NewArrayType(ResolvedType.New(QsType.Qubit)));
var unitType = ResolvedType.New(QsType.UnitType);
var doubleType = ResolvedType.New(QsType.Double);
var oracleType = ResolvedType.New(QsType.NewUserDefinedType(new UserDefinedType(CanonName,
NonNullable <string> .New("DiscreteOracle"),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null)));
var noInfo = CallableInformation.NoInformation;
var acFunctors = ResolvedCharacteristics.FromProperties(new[] { OpProperty.Adjointable, OpProperty.Controllable });
var acInfo = new CallableInformation(acFunctors, InferredCallableInformation.NoInformation);
var qubitToUnitOp = ResolvedType.New(QsType.NewOperation(new SigTypeTuple(qubitArrayType, unitType), noInfo));
var qubitToUnitOpAC = ResolvedType.New(QsType.NewOperation(new SigTypeTuple(qubitArrayType, unitType), acInfo));
var phaseEstArgs = new ResolvedType[] { oracleType, qubitArrayType }.ToImmutableArray();
var phaseEstArgTuple = ResolvedType.New(QsType.NewTupleType(phaseEstArgs));
var phaseEstOp = ResolvedType.New(QsType.NewOperation(new SigTypeTuple(phaseEstArgTuple, doubleType), noInfo));
var typeParams = new QsLocalSymbol[] { }.ToImmutableArray();
var argTypes = new ResolvedType[] { qubitToUnitOp, qubitToUnitOp, qubitToUnitOpAC, phaseEstOp, qubitArrayType }.ToImmutableArray();
var argTupleType = ResolvedType.New(QsType.NewTupleType(argTypes));
var signature = new ResolvedSignature(typeParams, argTupleType, doubleType, noInfo);
var args = new List <ArgDeclType> {
BuildArgument("statePrepUnitary", qubitToUnitOp),
BuildArgument("adiabaticUnitary", qubitToUnitOp),
BuildArgument("qpeUnitary", qubitToUnitOpAC),
BuildArgument("phaseEstAlgorithm", phaseEstOp),
BuildArgument("qubits", qubitArrayType)
}
.ConvertAll(arg => QsTuple <ArgDeclType> .NewQsTupleItem(arg))
.ToImmutableArray();
var argTuple = QsTuple <ArgDeclType> .NewQsTuple(args);
var specs = new QsSpecialization[] { }.ToImmutableArray();
var qsCallable = new QsCallable(QsCallableKind.Operation,
MakeFullName("AdiabaticStateEnergyUnitary"),
NonNullable <string> .New("Techniques.qs"),
ZeroLocation,
signature,
argTuple,
specs,
comments.ToImmutableArray(),
QsComments.Empty);
var callable = new DocCallable("Microsoft.Quantum.Canon", qsCallable);
var stream = new StringWriter();
callable.WriteToFile(stream);
var s = stream.ToString();
Assert.Equal(expected, s);
}
public void EqualityMethod()
{
string x = new string('1', 10);
string y = new string('1', 10);
string z = new string('z', 10);
NonNullable<string> xx = x;
NonNullable<string> yy = y;
NonNullable<string> zz = z;
NonNullable<string> nn = new NonNullable<string>();
Assert.IsTrue(xx.Equals(xx));
Assert.IsTrue(xx.Equals(yy));
Assert.IsFalse(xx.Equals(zz));
Assert.IsFalse(xx.Equals(nn));
Assert.IsFalse(nn.Equals(xx));
}
private QsQualifiedName MakeFullName(string name)
{
return(new QsQualifiedName(CanonName, NonNullable <string> .New(name)));
}
public void ParseUdt()
{
string[] comments =
{
"# Summary",
"Represents a single primitive term in the set of all dynamical generators, e.g.",
"Hermitian operators, for which there exists a map from that generator",
"to time-evolution by that that generator, through \"EvolutionSet\".",
"",
"# Description",
"The first element",
"(Int[], Double[]) is indexes that single term -- For instance, the Pauli string",
"XXY with coefficient 0.5 would be indexed by ([1,1,2], [0.5]). Alternatively,",
"Hamiltonians parameterized by a continuous variable, such as X cos φ + Y sin φ,",
"might for instance be represented by ([], [φ]). The second",
"element indexes the subsystem on which the generator acts on.",
"",
"# Remarks",
"> [!WARNING]",
"> The interpretation of an `GeneratorIndex` is not defined except",
"> with reference to a particular set of generators.",
"",
"# Example",
"Using <xref:microsoft.quantum.canon.paulievolutionset>, the operator",
"$\\pi X_2 X_5 Y_9$ is represented as:",
"```qsharp",
"let index = GeneratorIndex(([1; 1; 2], [PI()]), [2; 5; 9]);",
"```",
"",
"# See Also",
"- @\"microsoft.quantum.canon.paulievolutionset\"",
"- @\"microsoft.quantum.canon.evolutionset\""
};
string expected = @"### YamlMime:QSharpType
uid: microsoft.quantum.canon.generatorindex
name: GeneratorIndex
type: newtype
namespace: Microsoft.Quantum.Canon
summary: |-
Represents a single primitive term in the set of all dynamical generators, e.g.
Hermitian operators, for which there exists a map from that generator
to time-evolution by that that generator, through ""EvolutionSet"".
The first element
(Int[], Double[]) is indexes that single term -- For instance, the Pauli string
XXY with coefficient 0.5 would be indexed by ([1,1,2], [0.5]). Alternatively,
Hamiltonians parameterized by a continuous variable, such as X cos φ + Y sin φ,
might for instance be represented by ([], [φ]). The second
element indexes the subsystem on which the generator acts on.
remarks: |-
> [!WARNING]
> The interpretation of an `GeneratorIndex` is not defined except
> with reference to a particular set of generators.
### Examples
Using <xref:microsoft.quantum.canon.paulievolutionset>, the operator
$\pi X_2 X_5 Y_9$ is represented as:
```qsharp
let index = GeneratorIndex(([1; 1; 2], [PI()]), [2; 5; 9]);
```
syntax: newtype GeneratorIndex = ((Int[], Double[]), Int[]);
seeAlso:
- microsoft.quantum.canon.paulievolutionset
- microsoft.quantum.canon.evolutionset
...
";
var intArrayType = ResolvedType.New(QsType.NewArrayType(ResolvedType.New(QsType.Int)));
var doubleArrayType = ResolvedType.New(QsType.NewArrayType(ResolvedType.New(QsType.Double)));
var innerTuple = new ResolvedType[] { intArrayType, doubleArrayType }.ToImmutableArray();
var innerTupleType = ResolvedType.New(QsType.NewTupleType(innerTuple));
var baseTuple = new ResolvedType[] { innerTupleType, intArrayType }.ToImmutableArray();
var baseType = ResolvedType.New(QsType.NewTupleType(baseTuple));
var anonymousItem = QsTuple <QsTypeItem> .NewQsTupleItem(QsTypeItem.NewAnonymous(baseType));
var typeItems = QsTuple <QsTypeItem> .NewQsTuple(ImmutableArray.Create(anonymousItem));
var generatorIndexType = new QsCustomType(MakeFullName("GeneratorIndex"),
NonNullable <string> .New("GeneratorRepresentation.qs"),
ZeroLocation,
baseType,
typeItems,
comments.ToImmutableArray(),
QsComments.Empty);
var udt = new DocUdt("Microsoft.Quantum.Canon", generatorIndexType);
var stream = new StringWriter();
udt.WriteToFile(stream);
var s = stream.ToString();
Assert.Equal(expected, s);
}
public static byte[] KeyFromPassword(NonNullable <string> password, byte[] salt = null, int iterations = DefaultIterations, int keyLength = DefaultKeyLength) => KeyFromPassword(Encoding.UTF8.GetBytes(password.Value), salt, iterations, keyLength);
public void EqualityOperator()
{
string x = new string('1', 10);
string y = new string('1', 10);
string z = new string('z', 10);
NonNullable<string> xx = x;
NonNullable<string> yy = y;
NonNullable<string> zz = z;
NonNullable<string> nn = new NonNullable<string>();
#pragma warning disable 1718
Assert.IsTrue(xx == xx);
Assert.IsTrue(yy == yy);
Assert.IsTrue(zz == zz);
Assert.IsTrue(nn == nn);
#pragma warning restore 1718
Assert.IsFalse(xx == yy);
Assert.IsFalse(yy == zz);
Assert.IsFalse(zz == nn);
Assert.IsFalse(nn == xx);
}
public static IDisposable On <T1, T2, T3, T4, T5, T6, T7, T8>(this SignalRChannel channel, string methodName, Action <T1, T2, T3, T4, T5, T6, T7, T8> handler)
{
var connection = new NonNullable <HubConnection>(channel.Connection);
return(connection.Value.On(methodName, handler));
}
public void Value_ThrowExceptionIfValueNull()
{
//This is the only way to create a NonNullable that contains a null reference.
//C# does not allow overriding the default constructor on structs.
NonNullable<string> str = new NonNullable<string>();
string s = str.Value;
}
public static IDisposable On(this SignalRChannel channel, string methodName, Type[] parameterTypes, Func <object[], Task> handler)
{
var connection = new NonNullable <HubConnection>(channel.Connection);
return(connection.Value.On(methodName, parameterTypes, handler));
}
public void Constructor_ConstructViaConstructor_NullReference()
{
NonNullable<string> str = new NonNullable<string>(null);
}
: new QsQualifiedName(NonNullable <string> .New(@namespace), NonNullable <string> .New(name));
public void Constructor_DefaultConstructorCausesExceptionWhenValueRetrieved()
{
NonNullable<string> str = new NonNullable<string>();
string str2 = str.Value;
}
public static byte[] KeyFromPassword(NonNullable <string> password, byte[] salt = null, int iterations = DefaultIterations, int keyLength = DefaultKeyLength) => KeyFromPassword(password.Value.Utf8ToBytes(), salt, iterations, keyLength);
private bool ImplicitCastMethod(NonNullable<string> str)
{
return true;
}
/// <summary> /// Builds a string literal with the given content that can be used as argument to a Q# attribute. /// The value of the string literal is set to the empty string if the given content is null. /// </summary> public static TypedExpression StringArgument(string content) => SyntaxGenerator.StringLiteral(NonNullable <string> .New(content ?? ""), ImmutableArray <TypedExpression> .Empty);