Tipli program sonuçları ve sembolik hatalar

Float matematiği ve aktivasyonlar

Trigonometrik, üstel, logaritmik ve aktivasyon fonksiyonlarıyla sayısal hesaplar veya dönüş açıları oluşturun. Bu katalogdaki fonksiyonlar bir Float argümandan Float sonuç üretir; Int için int_to_float(...) kullanın. Sinüs/kosinüs ayrıca Angle kabul eder. Float açılar radyandır; derece için degrees(...) ile açık bir Angle oluşturun.

• sin(value: Float) -> Float — Radyan cinsinden Float açının sinüsü. Angle girdisini de kabul eder ve kanonik radyan miktarından Float sonuç üretir.
• cos(value: Float) -> Float — Radyan cinsinden Float açının kosinüsü. Angle girdisini de kabul eder ve kanonik radyan miktarından Float sonuç üretir.
• sqrt(value: Float) -> Float — Negatif olmayan Float değerin karekökü.
• exp(value: Float) -> Float — Float değerin doğal üstel fonksiyonu; Float sınırını aşan sonuçlar reddedilir.
• log(value: Float) -> Float — Sıfırdan büyük Float değerin doğal logaritması.
• log1p(value: Float) -> Float — 1 + değerin sıfır yakınında hassas doğal logaritması; girdi -1 değerinden büyük olmalıdır.
• expm1(value: Float) -> Float — Doğal üstel fonksiyon eksi bir; sıfır yakınında hassastır, Float sınırını aşan sonuçlar reddedilir.
• tanh(value: Float) -> Float — Float değerin [-1, 1] aralığındaki hiperbolik tanjantı.
• sigmoid(value: Float) -> Float — Float değerin [0, 1] aralığındaki sayısal olarak kararlı lojistik sigmoid değeri.
• abs(value: Float) -> Float — Float değerin mutlak değeri; parametreye bağlı sıfırda analitik türev tanımsızdır.
• floor(value: Float) -> Float — Aşağı yuvarlanmış tam sayı değerli Float; parametreye bağlı tam sayı girdilerde analitik türev reddedilir.
• ceil(value: Float) -> Float — Yukarı yuvarlanmış tam sayı değerli Float; parametreye bağlı tam sayı girdilerde analitik türev reddedilir.
• round(value: Float) -> Float — En yakın tam sayı değerli Float; yarımlar pozitif sonsuz yönüne yuvarlanır, parametreye bağlı yarım sayılarda analitik türev reddedilir.

Vektörler ve sayısal işlemler

• min(Float, Float) -> Float — En küçük değer
• max(Float, Float) -> Float — En büyük değer
• clamp(Float, Float, Float) -> Float — Kapalı aralığa sınırla
• sum(Array<T, N>) -> T — Sınır denetimli toplam
• dot(Array<T, N>, Array<T, N>) -> T — İç çarpım
• norm(Array<Float, N>) -> Float — Öklid normu
• add(Array<T, N>, Array<T, N>) -> Array<T, N> — Eleman bazlı toplama
• sub(Array<T, N>, Array<T, N>) -> Array<T, N> — Eleman bazlı çıkarma
• scale(Array<T, N>, T) -> Array<T, N> — Skaler çarpma
• variance(Array<Float, N>) -> Float — Popülasyon varyansı
• stddev(Array<Float, N>) -> Float — Popülasyon standart sapması
• argmin(Array<T, N>) -> Int — İlk minimum indisi
• argmax(Array<T, N>) -> Int — İlk maksimum indisi

T, Int veya Float; N ise 1–256 arasında sabit dizi uzunluğudur. İki vektörün tipi ve uzunluğu aynı olmalı; scale çarpanı eleman tipiyle eşleşmelidir. sum/dot eleman tipini korur. min/max/clamp yalnız Float alır; clamp alt sınırı üst sınırı aşamaz. norm/variance/stddev yalnız Float dizisi alır. variance popülasyon varyansıdır (N değerine bölünür); stddev bunun kareköküdür. argmin/argmax sıfır tabanlı Int indis döndürür; eşitlikte ilk elemanı seçer. Örnekte bend, dot ile aynı dönüş açısını hesaplar; magnitude vektör uzunluğunu, spread varyansı gösterir.

Analitik türev; parametreye bağlı argmin/argmax, min/max eşitliği, norm sıfırı ve birden çok elemanlı stddev sıfırında reddedilir. clamp için parametreye bağlı sınır temasları reddedilir; iki sabit sınır eşitse sonuç sabittir ve türev sıfırdır. Tek elemanlı stddev sıfır türev verir. Sabit işlemler türev kısıtlamalarından etkilenmez; sayısal aralık ve şekil denetimleri yine uygulanır. Vektör işlemleri yardımcı yürütme bütçesinden eleman sayısına göre pay tüketir.

Tipli main ifadesi için typedClassicalValues yeterlidir. Yardımcı gövdesi veya doğrudan kapı açısında kullanım için classicalFunctions da gerekir. Örnek iki seçeneği açar; scale = 2, wave ≈ 0.389418 ve Z beklentisi ≈ 0.952382 olur. sin/cos/sqrt çağrıları import edilen yardımcıların içinde de kullanılabilir; standart kütüphane importu gerekmez.

1module float_math;2param theta: Angle = 0.4;3 4fn bend(x: Float) -> Float {5  return dot([sin(x), cos(x)], [1.0, 0.25]);6}7 8fn main() {9  let q = qreg[1];10  let scale: Float = sqrt(int_to_float(4));11  let wave: Float = sin(theta);12  let probability: Float = sigmoid(theta);13  let activation: Float = tanh(theta);14  let features: Array<Float, 2> = [wave, activation];15  let magnitude: Float = norm(features);16  let spread: Float = variance(features);17  let bounded: Float = clamp(probability, 0.0, 1.0);18  Ry(q[0], bend(theta) / scale);19  Rz(q[0], cos(theta));20  let cost = expect Z(q[0]);21  return cost;22}

sqrt(-1.0) bir çalışma hatasıdır; sıfır ya da NaN sonucu olarak gizlenmez. sqrt(0.0) normal hesapta geçerlidir. Bu sürüm, sıfırda parametreye bağlı sqrt üzerinden analitik türev hesaplamayı desteklemez; eğitim/gradient bunu açıkça reddeder. Parametreden bağımsız sqrt(0.0) sabit kalır. Seçilmeyen kısa devre dalı değerlendirilmez.

log sıfırdan büyük, log1p ise -1 değerinden büyük girdi ister. exp ve expm1 sonuçları 10¹² Float sınırını aşarsa hata verir. log1p/expm1 sıfır yakınındaki hassasiyeti korur. Sigmoid ve tanh büyük girdilerde taşmayı önler; kayan nokta yuvarlaması uç değerleri üretebilir. Örnekte probability ≈ 0.598688 ve activation ≈ 0.379949 olur.

abs, floor, ceil ve round Float döndürür. round yarım değerleri pozitif sonsuz yönüne yuvarlar: round(-1.5) = -1.0. Parametreye bağlı abs sıfırda, floor/ceil tam sayılarda, round yarım sayılarda analitik türev hatası verir. Diğer noktalarda yuvarlama türevi sıfırdır; yalnız yuvarlama üzerinden bağlı bir parametre gradyanla değişmez. Parametreden bağımsız sabitler bu türev kısıtlamasına girmez.

Tek argümanlı Float kataloğundaki adlar ayrılmıştır; özel yardımcı fonksiyonlara bu adları vermeyin. Aşağıdaki sayısal katalogda ise aynı adlı kullanıcı fonksiyonu, import edilenler dahil, yerleşik işlemden önce çözülür.

Ölçüm dallarında yardımcı fonksiyonlar

Seçilen main dalında tipli yerel değer, yardımcı çağrısı ve matematik içeren kapı açısı kullanın. classicalFunctions ve typedClassicalValues açıkken Bool değerleri ve Bool döndüren yardımcılarla iç içe if/else kullanılabilir; mevcut ölçüm koşulları da korunur.

Örnek classicalFunctions, typedClassicalValues ve functionResults seçeneklerini açar. X kapısı ölçümü 1 yapar: angle ≈ 0.479426 döner. X(q[0]) satırını kaldırınca ZERO_MEASUREMENT hatası döner. checked_angle(0.5)? çağrısını checked_angle(-0.5)? yapınca NEGATIVE_ANGLE hatası Ry kapısından önce döner. Yalnız seçilen dal çalışır; erken Result dönüşü sonraki işlemleri durdurur.

1module measured_helpers;2 3fn checked_angle(value: Float) -> Result<Float, Error> {4  if (value < 0.0) {5    return error("NEGATIVE_ANGLE");6  }7  return ok(sin(value));8}9 10fn main() -> Result<Float, Error> {11  let q = qreg[2];12  X(q[0]);13  let measured: Bit = measure(q[0]);14  if (measured == 1) {15    let angle: Float = checked_angle(0.5)?;16    Ry(q[1], cos(angle));17    return ok(angle);18  } else {19    return error("ZERO_MEASUREMENT");20  }21}

Blok yerelleri blok dışında görünmez. Kardeş dallar aynı adı kullanabilir; dış kapsamdaki değeri aynı adla gölgelemek reddedilir. Editör tamamlama, tür bilgisi, başvuru ve yeniden adlandırmada bu sınırları korur. Yeniden adlandırma tam ve geçerli kaynak gerektirir. Int/Float let mut ve sabit aralıklı for döngüleri ortak 4096 işlem adımı bütçesiyle çalışır; sınırsız tekrar desteklenmez.

Statevector motoru observe/test/snapshot bloklarında yardımcıları destekler. MPS bu rapor bloklarını ve until akışını açıkça reddeder; stabilizer rapor bloklarında statevector motoruna geçer. Dinamik kontrol içindeki yardımcı çağrılarını QASM veya framework devresine yansıtma NM-CFN-011 ile reddedilir; özgün N/M kaynağını saklayın.

Main içinde döngüler, dinamik indeksler ve Result

Örnekleri açan bağlantılar classicalFunctions, typedClassicalValues ve functionResults seçeneklerini birlikte etkinleştirir. Kaynak statevector, MPS ve stabilizer motorlarında çalışır; her motorun kapı desteği sınırları geçerlidir.

1module indexed_accumulation;2fn main() -> Result<Float, Error> {3  let q = qreg[2];4  let weights: Array<Float, 2> = [1.5, 3.0];5  let mut total: Float = 0.0;6  for i in 0..2 {7    total = total + weights[i];8    X(q[i]);9  }10  return ok(total);11}

1module main_result_recovery;2fn checked(value: Float) -> Result<Float, Error> {3  if (value < 0.0) { return error("NEGATIVE"); }4  return ok(value * 2.0);5}6fn main() -> Result<Float, Error> {7  let q = qreg[1];8  let attempt: Result<Float, Error> = checked(1.5);9  match (attempt) {10    ok(value) => {11      X(q[0]);12      return ok(value);13    }14    error => {15      return attempt;16    }17  }18}

1module mutation_gradient;2param theta:Angle=0.3;3fn main(){4 let q=qreg[1];5 let xs:Array<Float,3>=[theta,theta*theta,theta*3.0];6 let mut total:Float=0.0;7 let mut cursor:Int=2;8 for i in 0..3 {9  total=total+xs[cursor];10  cursor=cursor-1;11 }12 Ry(q[0],total);13 let cost=expect Z(q[0]);14 let slope=gradient cost wrt theta;15 return slope;16}

1module array_mutation_gradient;2param theta:Angle=0.3;3fn main(){4 let q=qreg[1];5 let mut xs:Array<Float,2>=[theta,theta*theta];6 let original:Array<Float,2>=xs;7 for i in 0..2 {8  xs[i]=xs[i]*theta;9 }10 xs[0]=xs[0]+original[0];11 Ry(q[0],xs[0]+xs[1]);12 let cost=expect Z(q[0]);13 let slope=gradient cost wrt theta;14 return slope;15}

Döngü sınırları sabit tamsayılardır: 0 ≤ başlangıç ≤ bitiş ≤ 256. İç içe döngüler, ifadeler ve yardımcılar ortak 4096 adım bütçesini tüketir. Kapı hedefleri Int olmalı, register sınırında kalmalı ve çok hedefli kapılarda birbirinden farklı olmalıdır. Dinamik indeks desteği ölçüm/reset hedeflerine genişletilmez.

Main Result payload'ı Int, Float, Bool, Bit veya sabit Int/Float/Bit dizisi olabilir; iç içe Result ve Bool dizileri desteklenmez. Bit, Int'e örtük dönüştürülmez. Sayısal yardımcılar Result parametresi kabul eder, ancak Bit payload için açık dönüşüm gerekir. Result hata sonucu başarılı bir motor yürütmesidir; sınır aşımı veya sıfıra bölme çalışma zamanı hatasıdır.

N/M kaynağı ve JSON IR bu örnekleri korur. Skaler main atamaları, sınırlı döngüler ve parametreden bağımsız dizi okumaları adjoint eğitiminde desteklenir; parametreden bağımsız Int qubit hedefleri sınır denetimiyle desteklenir. QASM/framework aktarımı ve optimizasyon bu dinamik akışı reddeder. Statik devre görünümü çözülmemiş hedefi q[?] olarak gösterir; kesin hesaplanamayan kaynak sınırları belirsiz olarak bildirilir.

Yardımcıda Result saklama ve hata kurtarma

Saf yardımcı fonksiyon içinde Result<T, Error> değerini tipli bir yerelde saklayın; match (attempt) ile ok(value) ve error kollarını açıkça ele alın. Her iki kol tam bir kez bulunmalıdır; sıraları değişebilir. Seçici bir Result yerelinin adı olmalıdır. ok içindeki değer T tipindedir ve yalnız o kolda görünür; error kolu ayrı bir hata değişkeni oluşturmaz.

Örnek üç deneysel seçeneği açar. recover(-1.0), NEGATIVE_ROOT hatasını bilinçli olarak Float: 0 değerine çevirir. recover(4.0), Float: 2 döndürür. main içindeki çağrıyı forward(-1.0)? yaparsanız özgün NEGATIVE_ROOT kodu korunur ve Ry çalışmadan programdan dönülür. Hatalar kendiliğinden başarıya çevrilmez; fallback değeri kaynakta açıkça seçilir.

1module result_recovery;2 3fn checked_root(value: Float) -> Result<Float, Error> {4  if (value < 0.0) {5    return error("NEGATIVE_ROOT");6  }7  return ok(sqrt(value));8}9 10fn recover(value: Float) -> Float {11  let attempt: Result<Float, Error> = checked_root(value);12  match (attempt) {13    ok(root) => {14      return root;15    }16    error => {17      return 0.0;18    }19  }20}21 22fn forward(value: Float) -> Result<Float, Error> {23  let attempt: Result<Float, Error> = checked_root(value);24  match (attempt) {25    ok(root) => {26      return ok(root);27    }28    error => {29      return attempt;30    }31  }32}33 34fn main() -> Result<Float, Error> {35  let q = qreg[1];36  let value: Float = recover(-1.0);37  Ry(q[0], value);38  return ok(value);39}

Result yerelleri ve eksiksiz iki kollu match, üç deneysel seçenek açıkken yardımcılarda ve main içinde kullanılabilir. Yardımcılar Result parametreleri de kabul eder. İç içe Result desteklenmez. T; Int, Float, Bool veya sabit Int/Float dizisi olabilir. Yerel attempt? Result döndüren bir yardımcıda veya main içinde başarıyı açar veya özgün hatayı iletir. Örneğin return ok(attempt?);. error kolunda return attempt; özgün hata kodunu korur. ok bağlaması da 32 yerel sınırına dahildir. Bu yerleşik Error Result örneğindeki yardımcıların analitik türevi desteklenmez. Tipli hata kurtarma türevleri ayrı sözleşmeyle desteklenir.

Editör Result yerelinin ve ok değerinin tipini gösterir. Tamamlama, tanıma gitme, başvuru ve yeniden adlandırma kol sınırını korur; başka bir yardımcının aynı adlı değerini değiştirmez. Dış kapsamdaki bir adı gölgeleyen yeniden adlandırma reddedilir.

Result içinde kayıt ve enum taşıma

Bir yardımcı başarılı olduğunda tek sayı yerine bir kayıt veya enum döndürebilir. Result<Sample,Problem> içindeki Sample başarı tipidir; Problem hata enumudur. match başarı kolunda kaydın alanlarını, hata kolunda hata varyantını açar. Tiplerin modül kimliği dosyalar arası çağrılarda da korunur.

checked(0.5), energy alanı 0.25 olan bir kayıt üretir; devrenin beklentisi cos(0.25) olur. Girdiyi -1.0 yaparsanız yalnız hata kolu çalışır ve kaynakta seçilen 0.5 açısı uygulanır. Örnek üç deneysel seçeneği açar.

1module aggregate_result;2record Sample {energy:Float}3enum Problem {Negative}4 5fn checked(value:Float)->Result<Sample,Problem>{6 if(value<0.0){return error(Problem.Negative);}7 return ok(Sample {energy:value*value});8}9 10fn main(){11 let q=qreg[1];12 let attempt:Result<Sample,Problem>=checked(0.5);13 match(attempt){14  ok(sample)=>{Ry(q[0],sample.energy);}15  error(reason)=>{Ry(q[0],0.5);}16 }17 let cost=expect Z(q[0]);18 return cost;19}

Başarı kaydı ve hata enumu farklı dosyalarda da tanımlanabilir. Dört dosyalı örnek kayıt ve enum sonuçlarını birlikte kullanır; beklenti cos(0.5) olur. Ana dosyadaki iki 0.5 girdisini -1.0 yaparsanız hata kolları çalışır ve beklenti cos(0.75) olur.

main de kaydı doğrudan program sonucu olarak döndürebilir. Bu örnekte sonuç energy: 0.25 olur. checked girdisini -1.0 yaparsanız ? hatayı döndürür; ilk X kapısı korunur, ikinci X çalışmaz. Programın tipli hata dönmesi, simülatörün çalıştırma hatası vermesinden farklıdır.

Dizi, Complex ve matris sonuçları

Bu örnek iki elemanlı bir Complex matris döndürür: complex(0.25, 0) ve complex(0.5, 1). checked girdisini -1.0 yaparsanız Negative hatası döner; ilk X uygulanır, ikinci X atlanır. Dizi uzunluğu ile matrisin boyutları ve eleman tipi başarı ve hata yollarında korunur.

1module compound_result_lesson;2enum Problem {Negative}3fn checked(x:Float)->Result<Matrix<Complex,1,2>,Problem>{4 if(x<0.0){return error(Problem.Negative);}5 return ok(complex_matrix(1,2,[x,0.5],[0.0,1.0]));6}7fn main()->Result<Matrix<Complex,1,2>,Problem>{8 let q=qreg[1];9 X(q[0]);10 let value:Matrix<Complex,1,2>=checked(0.25)?;11 X(q[0]);12 return ok(value);13}

Kayıt/enum ve sayısal dizi/Complex/matris başarı değerleri yardımcı dönüşlerinde, Result parametrelerinde, main yerellerinde ve main program sonucunda kullanılabilir. Aynı hata enumuna sahip Result döndüren fonksiyonlarda ? başarıyı açar veya hatayı iletir. Generic kayıt ve enum tipleri aşağıdaki örnekte gösterilir. İç içe Result desteklenmez. Tipli hata kurtarma hesaplarının sayısal türevleri desteklenir; parametreye bağlı ayrık kol seçimleri reddedilir.

Generic kayıtlar ve değer taşıyan enumlar

Box<T>, farklı tipleri aynı kayıt yapısında saklar: Box<Sample> bir örnek, Box<Int> bir tam sayı taşır. Problem<T>.Bad(T) hata ile birlikte bir değer döndürür. Tip argümanları iç içe yazılabilir; her alanın tipi derleme sırasında denetlenir.

Playground’da kaynak ve bağlamı yükleyip Çalıştır’ı seçin. attempt(false), energy: 0.25 içeren bir kayıt döndürür. İki X kapısı birbirini geri alır; son durum |0⟩ olur.

attempt(false) yerine attempt(true) yazıp yeniden çalıştırın. Hata, Box<Int> içinde 7 değerini taşır. ? ikinci X kapısından önce programı bitirir; son durum |1⟩ olur. Bu bir tipli program sonucudur; simülatörün çalıştırma hatası değildir.

1module model;2pub record Box<T> { value: T }

1module values;2pub record Sample { energy: Float }

1module problem;2pub enum Problem<T> { Missing, Bad(T) }

1module app;2use workspace.model as m;3use workspace.values as v;4use workspace.problem as e;5 6fn attempt(failed: Bool) -> Result<m.Box<v.Sample>, e.Problem<m.Box<Int>>> {7  if (failed) {8    return error(e.Problem<m.Box<Int>>.Bad(m.Box<Int> { value: 7 }));9  }10  return ok(m.Box<v.Sample> { value: v.Sample { energy: 0.25 } });11}12 13fn main() -> Result<m.Box<v.Sample>, e.Problem<m.Box<Int>>> {14  let q = qreg[1];15  X(q[0]);16  let sample: m.Box<v.Sample> = attempt(false)?;17  X(q[0]);18  return ok(sample);19}

Box tipinin kullanımlarına gidin, kaydın value alanını yeniden adlandırın veya .Bad( çağrısında yük tipini inceleyin. match ile açılan enum değişkenleri yalnız kendi kolunda görünür. Dosyalar arası yeniden adlandırma, etkilenen kodun geçerliliğini denetler.

m, v ve e dosya takma adlarıdır. Takma adlar tip kimliğini değiştirmez; başka bir modüldeki aynı alanlara sahip Sample farklı bir tiptir. Yalnız pub bildirimleri başka dosyalardan kullanılabilir.

Deneyseldir. Bildirim başına en çok 4 tip parametresi, enum varyantı başına 8 yük öğesi ve derleme başına 256 somut nominal tip desteklenir. Özyinelemeli tipler ve iç içe Result desteklenmez. İç içe kayıt, enum yükleri ve tipli hata kurtarmanın sayısal türevleri desteklenir; parametreye bağlı ayrık kararlar reddedilir. Main skaler/dizi güncellemelerinin türevleri aşağıdaki main çalışma zamanı sözleşmesine tabidir.

İç içe değerlerden kapı açısına ve türeve

Bu örnekte açı, Box → Choice.Some → Box içinden geçer. Kaynak ve bağlamı yükleyip çalıştırın: slope, theta değiştiğinde Z beklentisinin nasıl değiştiğini verir. Beklenen türev −sin(0.29/1.04) × 0.6/1.04 olur. match yalnız seçilen yükü açar; sayısal değerin türevini korur.

1module nested_gradient;2param theta:Angle=0.3;3param phi:Angle=0.2;4record Box<T>{value:T}5enum Choice<T>{None,Some(T)}6fn make(x:Float,y:Float)->Box<Choice<Box<Float>>> {7  return Box<Choice<Box<Float>>>{value:Choice<Box<Float>>.Some(Box<Float>{value:(x*x+y)/(y*y+1.0)})};8}9fn angle(item:Box<Choice<Box<Float>>>)->Float {10  return match(item.value){Choice<Box<Float>>.None=>0.0,Choice<Box<Float>>.Some(sample)=>sample.value};11}12fn main(){13  let q=qreg[1];14  let item:Box<Choice<Box<Float>>>=make(theta,phi);15  Ry(q[0],angle(item));16  let cost=expect Z(q[0]);17  let slope=gradient cost wrt theta;18  return slope;19}

Hata yükünden kurtarma ve türev

checked, theta² değerini hata yükünde taşır. ? sonraki hesabı atlar; recover yükü ikiyle çarpar. Kapı açısı 2 × theta² olur. Çalıştırınca slope yaklaşık −0.214835488111 çıkar. Hata kolunun seçimi parametreden bağımsızdır; hata içindeki sayı ise türevini korur.

1module recovery_gradient;2param theta:Angle=0.3;3record Box<T>{value:T}4enum Problem<T>{Bad(T),Empty}5fn checked(x:Float)->Result<Box<Float>,Problem<Box<Float>>>{6 return error(Problem<Box<Float>>.Bad(Box<Float>{value:x*x}));7}8fn forwarded(x:Float)->Result<Float,Problem<Box<Float>>>{9 let item:Box<Float>=checked(x)?;10 return ok(item.value*3.0);11}12fn recover(result:Result<Float,Problem<Box<Float>>>)->Float{13 match(result){14  ok(value)=>{return value;}15  error(reason)=>{return match(reason){Problem<Box<Float>>.Bad(item)=>item.value*2.0,Problem<Box<Float>>.Empty=>0.0};}16 }17}18fn main(){19 let q=qreg[1];20 let result:Result<Float,Problem<Box<Float>>>=forwarded(theta);21 Ry(q[0],recover(result));22 let cost=expect Z(q[0]);23 let slope=gradient cost wrt theta;24 return slope;25}

Sınırlı yardımcı döngüsü ve değiştirilebilir sayısal yereller

Saf yardımcıda let mut ile açıkça bildirilen Int veya Float yereline aynı tipte yeni değer atayın. for i in 0..4 gövdesi i = 0, 1, 2, 3 için çalışır; bitiş sınırı dahil değildir. Sınırlar kaynakta yazılmış 0–256 tam sayı sabitleri olmalıdır. Eşit sınırlar sıfır tekrar demektir; ters aralık reddedilir.

Örnek dört Float değerini toplar: [0.1, 0.2, 0.3, 0.4] → Float: 1. 0..4 yerine 0..0 yazınca toplam 0 olur. 0..5 yaparsanız values[4] sınır hatası verir; dizi dışından sessiz değer okunmaz. Örnek classicalFunctions ve typedClassicalValues yanında main Result dönüşü için functionResults seçeneğini açar.

1module bounded_sum;2 3fn sum_values(values: Array<Float, 4>) -> Float {4  let mut sum: Float = 0.0;5  for i in 0..4 {6    sum = sum + values[i];7  }8  return sum;9}10 11fn main() -> Result<Float, Error> {12  let q = qreg[1];13  let values: Array<Float, 4> = [0.1, 0.2, 0.3, 0.4];14  let total: Float = sum_values(values);15  Ry(q[0], total);16  return ok(total);17}

Döngü indisi Int ve değiştirilemez; yalnız gövdede görünür. Parametreler, normal let yerelleri, ok payload ve diziler değiştirilemez. Yalnız let mut Int/Float yeniden atanabilir; örtük Int/Float dönüşümü yoktur. Döngü yerelleri her turda yeniden oluşturulur, blok dışına taşmaz ve dış adı gölgeleyemez. Döngüden sonra dönüş gerekir; yalnız döngü içindeki return yeterli sayılmaz. İç içe döngüler ve yardımcı çağrıları aynı 4096 değerlendirme adımı bütçesini paylaşır; while eklenmez.

Yardımcı içinde dizi indisi herhangi bir Int ifade olabilir: parametre, yerel, döngü indisi veya hesap. Negatif ya da dizi boyunu aşan indis çalışma hatasıdır. Main de classicalFunctions ve typedClassicalValues açıkken çalışma zamanı Int indislerini destekler; bu sayfadaki main çalışma zamanı örneklerine bakın. Analitik eğitim, yardımcı fonksiyonlarda 0–256 aralığında kaynakta yazılmış tam sayı sınırlarıyla (bitiş hariç) döngüleri, Int/Float yerel birikimlerini ve türevi alınan girdiden bağımsız, sınır denetimli Int indislerini destekler. İç içe çağrılar ve döngüler ortak 4096 adım bütçesini kullanır. Parametreye bağlı ayrık kararlar/indisler ve çalışma zamanında belirlenen döngü sınırları desteklenmez. Tipli Result kurtarma ve sınırlı main döngüsü türevleri kendi belgelenmiş sözleşmelerine tabidir.

Editör mut yerelini değiştirilebilir, döngü indisini salt okunur olarak gösterir. Referanslar ve yeniden adlandırma atamanın okuma/yazma taraflarını birlikte izler; kardeş döngünün aynı adlı indisini değiştirmez.

Modül takma adlarıyla aynı adlı yardımcıları ayırın

use workspace.scale as linear; yalnız linear.adjust(...) üzerinden erişim sağlar. İki modül aynı adjust adını dışa aktarabilir; düz adjust(...) adı takma adlı importtan gelmez. Örnekte linear.adjust(0.25) ve shifted.adjust(0.25) ayrı modüllerden 0.5 döndürür; sonuç Float: 1 olur.

Aktarım ana kaynakla scale ve offset modüllerini birlikte taşır. Playground'da kaynak ve bağlamı yüklemeyi açıkça onaylayın; classicalFunctions, typedClassicalValues, functionResults ve moduleVisibility özellikleri gösterilir. Ardından kendiniz çalıştırın. Aktarım otomatik çalıştırma yapmaz.

1module alias_demo;2use workspace.scale as linear;3use workspace.offset as shifted;4 5fn main() -> Result<Float, Error> {6  let q = qreg[1];7  let first: Float = linear.adjust(0.25);8  let second: Float = shifted.adjust(0.25);9  let angle: Float = first + second;10  Ry(q[0], angle);11  return ok(angle);12}

1module scale;2pub fn adjust(value: Float) -> Float {3  return value * 2.0;4}

1module offset;2private fn offset_value(value: Float) -> Float {3  return value + 0.25;4}5pub fn adjust(value: Float) -> Float {6  return offset_value(value);7}

Takma ad yalnız onu içe aktaran modülde geçerlidir. private yardımcılar ve dolaylı bağımlılıklar dışarı açılmaz; shifted.offset_value(...) reddedilir. Takma ad başka yardımcı, parametre veya yerel adını gölgeleyemez. Bu sözdizimi saf yardımcı importlarına aittir; genel modül nesnesi ya da yeniden dışa aktarım eklemez.

linear. sonrasında yalnız erişilebilir üyeler tamamlanır. Üye üzerinde F12 asıl yardımcı bildirgesine, takma ad üzerinde F12 import bildirgesine gider. Üyeyi yeniden adlandırmak asıl yardımcı ve tüketicilerini; takma adı yeniden adlandırmak yalnız bu modülün importunu ve niteleyicilerini değiştirir. Kaynak haritalı debugger asıl modül satırlarını korur.

Kayıtları ve tipli hataları dosyalar arasında kullanın

Bir dosya Sample kaydını ve Problem hata enumunu tanımlar; ana program bunları a takma adıyla kullanır. Takma ad değişse de tipin kimliği aynı kalır. Örnekte ilk X kapısı çalışır; negatif girişte ? ana programı hata ile bitirir ve ikinci X çalışmaz.

1module workspace_import_example;2use workspace.imported_types as a;3@target("browser-statevector");4fn main()->Result<Float,a.Problem>{5 let q=qreg[1];6 let sample:a.Sample=a.make(0.5);7 let angle:Float=a.read(sample);8 if(angle>0.0){X(q[0]);}9 let input:Result<Float,a.Problem>=a.checked(-1.0);10 let value:Float=input?;11 X(q[0]);12 return ok(value);13}

1module imported_types;2pub record Sample {energy:Float}3pub enum Problem {Negative}4private fn square(x:Float)->Float{return x*x;}5pub fn make(x:Float)->Sample{return Sample{energy:square(x)};}6pub fn read(sample:Sample)->Float{return sample.energy;}7pub fn checked(value:Float)->Result<Float,Problem>{8 if(value<0.0){return error(Problem.Negative);}9 return ok(value);10}

Çalıştırdıktan sonra Çalışma alanı dosyalarında kütüphanenin return error(Problem.Negative); satırını return ok(0.4); ile değiştirip tekrar çalıştırın. Bu kez ikinci X de çalışır ve program Float: 0.4 döndürür.

Deneysel özelliktir. Kaynak ve bağlamı yükledikten sonra çalıştırın. Özel üyeler dışarı açılmaz. Helper dönüşleri, main yerelleri ve main program sonucunda Result başarı değeri skaler, kayıt, enum, sabit boyutlu sayısal dizi, Complex veya matris olabilir. Generic kayıt/enum tipleri de dosyalar arasında kullanılabilir. Dosyalar arası tamamlama, tanıma gitme ve güvenli yeniden adlandırma desteklenir.

Kayıp fonksiyonunu ayrı dosyada geliştirin

losses.nm, tahmin ile etiket arasındaki farkı bir kayıtta tutar ve karesini hesaplar. Ana program a.loss fonksiyonunu iki adımlık eğitimde kullanır. Sonuç, aynı devrede yerleşik MSE kaybıyla eşleşir; bu bir simülatör alıştırmasıdır.

Kaynak ve bağlamı yükleyip Çalıştır'ı seçin. Sonuçtaki a.loss adını, eğitim geçmişini ve doğrulama/test kayıplarını inceleyin. Çalışma alanı dosyalarında losses.nm kaynağını düzenleyip yeniden çalıştırabilirsiniz.

1module learner;2use workspace.losses as a;3@dataset("moons_2d",split:"train");4param theta:Angle=0.37;5fn main(){6 let q=qreg[2];7 encode(sample_row(0),q,method:"angle");8 Ry(q[0],theta);9 let cost=expect Z(q[0]);10 train {11 objective:minimize cost;12 optimizer:gd(lr=0.1);13 steps:2;14 dataset:moons_2d;15 loss:custom(a.loss);16 validation: split = validation, every = 1;17 checkpoint: best(metric = validation_loss);18 }19 return cost;20}

1module losses;2pub record Residual {delta:Float}3enum State {Ready,Failed}4private fn squared(item:Residual)->Float{return item.delta*item.delta;}5pub fn loss(p:Float,y:Float)->Float {6 let item:Residual=Residual {delta:p-y};7 return match(State.Ready){State.Ready=>squared(item),State.Failed=>1.0/0.0};8}