PDL::BadValuesp - Online di Cloud

PROGRAM:

NAMA

PDL::BadValues ​​- Diskusi dukungan nilai buruk di PDL

DESKRIPSI

Apa adalah buruk nilai-nilai dan mengapa harus I mengganggu dengan mereka?
Terkadang berguna untuk dapat menentukan nilai tertentu 'buruk' atau 'hilang'; untuk
contoh CCD yang digunakan dalam astronomi menghasilkan gambar 2D yang tidak sempurna karena area tertentu
berisi data yang tidak valid karena ketidaksempurnaan dalam detektor. Sementara indeks kuat PDL
rutinitas dan semua bisnis yang rumit dengan aliran data, irisan, dll
daerah dapat diabaikan dalam pemrosesan, itu canggung untuk dilakukan. Akan jauh lebih mudah untuk menjadi
dapat mengatakan "$c = $a + $b" dan menyerahkan semua kerumitan ke komputer.

Jika Anda tidak tertarik dengan ini, maka Anda mungkin (benar) khawatir dengan bagaimana ini
mempengaruhi kecepatan PDL, karena overhead memeriksa nilai buruk di setiap operasi
bisa besar. Karena itu, kode telah ditulis secepat mungkin -
terutama ketika beroperasi pada piddle yang tidak mengandung nilai buruk. Sebenarnya, kamu
harus memperhatikan pada dasarnya tidak ada perbedaan kecepatan saat bekerja dengan piddle yang tidak
mengandung nilai buruk.

Namun, jika Anda tidak menginginkan nilai buruk, maka opsi konfigurasi "WITH_BADVAL" PDL
datang untuk menyelamatkan; jika disetel ke 0 atau undef, dukungan bernilai buruk akan diabaikan. Tentang
satu-satunya waktu saya pikir Anda harus menggunakan ini - saya akui, saya bias;) - adalah jika Anda punya
disk atau ruang memori terbatas, karena ukuran kode bertambah (lihat di bawah).

Anda mungkin juga bertanya 'baik, komputer saya mendukung IEEE NaN, jadi saya sudah memilikinya'. Baiklah
dan tidak - banyak rutinitas, seperti "y=sin(x)", akan menyebarkan NaN tanpa pengguna memiliki
untuk mengkode secara berbeda, tetapi rutinitas seperti "qsort", atau menemukan median array, perlu
untuk dikodekan ulang untuk menangani nilai-nilai buruk. Untuk tipe data titik-mengambang, "NaN" dan "Inf" adalah
digunakan untuk menandai nilai-nilai buruk IF opsi "BADVAL_USENAN" disetel ke 1 di file konfigurasi Anda.
Jika tidak, nilai khusus digunakan (Nilai buruk default). Saya tidak memiliki tolok ukur untuk
lihat opsi mana yang lebih cepat.

Ada fitur eksperimental "BADVAL_PER_PDL" yang, jika disetel, memungkinkan Anda memilikinya
nilai buruk yang berbeda untuk piddle terpisah dari jenis yang sama. Saat ini tidak berfungsi
dengan opsi "BADVAL_USENAN"; jika keduanya di set maka PDL akan mengabaikan "BADVAL_USENAN"
nilai.

Kode meningkat dua untuk buruk nilai-nilai
Perbandingan berikut sudah ketinggalan zaman!

Pada mesin i386 yang menjalankan Linux dan Perl 5.005_03, saya mengukur ukuran berikut (
Kode Slatec dikompilasi, tetapi tidak ada opsi lain: misalnya, FFTW, GSL, dan TriD
NS):

DENGAN_BADVAL = 0
Ukuran direktori blib setelah sukses make = 4963 kb: blib/arch = 2485 kb dan
blib/lib = 1587kb.

DENGAN_BADVAL = 1
Ukuran direktori blib setelah sukses make = 5723 kb: blib/arch = 3178 kb dan
blib/lib = 1613kb.

Jadi, peningkatan keseluruhan adalah hanya 15% - tidak banyak untuk membayar semua keajaiban yang bernilai buruk
menyediakan ;)

Kode sumber yang digunakan untuk pengujian ini memiliki sebagian besar rutinitas inti (mis
Dasar/) dikonversi untuk menggunakan nilai buruk, sementara sangat sedikit rutinitas 'eksternal' (yaitu
segala sesuatu yang lain dalam distribusi PDL) telah diubah.

A cepat ikhtisar
pdl> p $PDL::Buruk::Status
1
pdl> $a = urutan(4,3);
pdl> p $a
[
[0 1 2 3]
[4 5 6 7]
[8 9 10 11]
]
pdl> $a = $a->setbadif( $a % 3 == 2 )
pdl> p $a
[
[ 0 1 BURUK 3]
[ 4 BURUK 6 7]
[BURUK 9 10 BURUK]
]
pdl> $a *= 3
pdl> p $a
[
[ 0 3 BURUK 9]
[ 12 BURUK 18 21]
[BURUK 27 30 BURUK]
]
pdl> p $a->jumlah
120

"demo bad" dan "demo bad2" dalam perldl atau pdl2 memberikan demonstrasi beberapa
hal-hal yang mungkin dengan nilai-nilai yang buruk. Ini juga tersedia di situs web PDL, di
http://pdl.perl.org/demos/. Lihat PDL::Bad untuk rutinitas yang berguna untuk bekerja dengan nilai buruk
dan t/buruk.t untuk melihat mereka beraksi.

Tujuannya adalah untuk:

· tidak mempengaruhi PDL secara signifikan untuk pengguna yang tidak membutuhkan dukungan nilai buruk

· secepat mungkin ketika dukungan nilai buruk dipasang

Jika Anda tidak pernah menginginkan dukungan nilai buruk, maka Anda menyetel "WITH_BADVAL" ke 0 in perldl.conf; PDL
maka tidak ada dukungan nilai buruk yang dikompilasi, jadi akan secepat dulu.

Namun, dalam kebanyakan kasus, dukungan nilai buruk memiliki pengaruh yang dapat diabaikan pada kecepatan, jadi Anda
harus mengatur "WITH_CONFIG" ke 1! Satu pengecualian adalah jika Anda kekurangan memori, karena jumlahnya
kode yang dihasilkan lebih besar (tetapi hanya sekitar 15% - lihat "Kode bertambah karena buruk
nilai").

Untuk mengetahui apakah PDL telah dikompilasi dengan dukungan nilai buruk, lihat nilai keduanya
$PDL::Config{WITH_BADVAL} atau $PDL::Bad::Status - jika benar maka benar.

Untuk mengetahui apakah rutin mendukung nilai buruk, gunakan perintah "badinfo" di perldl atau pdl2
atau opsi "-b" ke pdldoc. Fasilitas ini saat ini merupakan 'bukti konsep' (atau, lebih)
secara realistis, retasan cepat) jadi harapkan itu menjadi kasar di tepinya.

Setiap piddle berisi sebuah bendera - dapat diakses melalui "$pdl->badflag" - untuk mengatakan apakah ada
data buruk hadir:

· Jika salah/0, yang berarti tidak ada data buruk di sini, kode yang diberikan oleh "Kode"
opsi untuk "pp_def()" dijalankan. Ini berarti kecepatannya harus sangat dekat dengan
yang diperoleh dengan "WITH_BADVAL=0", karena satu-satunya overhead adalah beberapa akses ke a
bit dalam variabel status piddles.

· Jika benar/1, maka ini mengatakan di sana MUNGKIN menjadi data yang buruk di piddle, jadi gunakan kode di
Opsi "BadCode" (dengan asumsi bahwa "pp_def()" untuk rutinitas ini telah diperbarui ke
memiliki kunci BadCode). Anda mendapatkan semua keuntungan dari threading, seperti dengan "Kode"
opsi, tetapi itu akan berjalan lebih lambat karena Anda harus menangani kehadiran
nilai-nilai buruk.

Jika Anda membuat piddle, flag nilai buruknya akan disetel ke 0. Untuk mengubahnya, gunakan
"$pdl->badflag($new_bad_status)", di mana $new_bad_status bisa 0 atau 1. Saat rutin
membuat piddle, flag bernilai buruknya akan bergantung pada piddle input: kecuali ditunggangi
(lihat opsi "CopyBadStatusCode" ke "pp_def"), tanda nilai buruk akan disetel ke true jika
salah satu piddle input mengandung nilai buruk. Untuk memeriksa apakah piddle benar-benar mengandung yang buruk
data, gunakan metode "check_badflag".

CATATAN: penyebaran bendera buruk

Jika Anda mengubah bendera buruk dari piddle, perubahan ini disebarkan ke semua anak-anak dari
piddle, jadi

pdl> $a = nol(20,30);
pdl> $b = $a->slice('0:10,0:10');
pdl> $c = $b->slice(',(2)');
pdl> print ">>c: ", $c->badflag, "\n";
>> c: 0
pdl> $a->bendera buruk(1);
pdl> print ">>c: ", $c->badflag, "\n";
>> c: 1

Tidak perubahan dilakukan pada orang tua dari sebuah piddle, jadi

pdl> print ">>a: ", $a->badflag, "\n";
>>a: 1
pdl> $c->bendera buruk(0);
pdl> print ">>a: ", $a->badflag, "\n";
>>a: 1

Pikiran:

· badflag HANYA dapat dihapus JIKA piddle TIDAK memiliki orang tua, dan perubahan ini akan
menyebar ke semua anak dari piddle itu. Saya tidak begitu tertarik pada ini lagi (juga
canggung untuk kode, untuk satu).

· "$a->bendera buruk(1)" harus menyebarkan badflag ke KEDUA orang tua dan anak-anak.

Ini seharusnya tidak sulit untuk diterapkan (walaupun upaya awal gagal!). Apakah itu membuat?
masuk akal? Ada juga masalah apa yang terjadi jika Anda mengubah nilai buruk dari a
piddle - haruskah ini menyebar ke anak-anak/orang tua (ya) atau apakah Anda seharusnya
dapat mengubah nilai buruk di tingkat 'atas' - yaitu piddle yang tidak memiliki
orangtua.

Metode "orig_badvalue()" mengembalikan nilai waktu kompilasi untuk tipe data tertentu. Berhasil
pada piddles, PDL::Ketik objek, dan angka - mis

$pdl->orig_badvalue(), byte->orig_badvalue(), dan asal_nilai_buruk(4).

Namanya juga mengerikan...

Untuk mendapatkan nilai buruk saat ini, gunakan metode "badvalue()" - metode ini memiliki sintaks yang sama dengan
"orig_badvalue()".

Untuk mengubah nilai buruk saat ini, berikan nomor baru ke nilai buruk - mis

$pdl->badvalue(2.3), byte->nilai buruk(2), nilai buruk(5,-3e34).

Note: nilai secara diam-diam dikonversi ke tipe C yang benar, dan dikembalikan - yaitu
"byte->badvalue(-26)" mengembalikan 230 di mesin Linux saya. Ini juga merupakan "tidak" untuk mengambang-
jenis titik ketika "BADVAL_USENAN" benar.

Perhatikan bahwa perubahan pada nilai buruk adalah JANGAN disebarkan ke piddle yang dibuat sebelumnya - mereka
akan tetap memiliki nilai buruk yang ditetapkan, tetapi tiba-tiba elemen yang buruk akan menjadi
'baik', tetapi mengandung nilai buruk yang lama. Lihat pembahasan di bawah ini. Itu tidak masalah untuk
tipe floating-point yang menggunakan NaN, karena Anda tidak dapat mengubah nilai buruknya.

Buruk nilai-nilai dan boolean operator
Untuk operator boolean di PDL::Ops, evaluasi pada nilai buruk mengembalikan nilai buruk.
Sementara ini berarti bahwa

$mask = $img > $thresh;

benar menyebarkan nilai-nilai buruk, itu akan menyebabkan masalah untuk pemeriksaan seperti

do_something() jika ada( $img > $thresh );

yang perlu ditulis ulang sebagai sesuatu seperti

do_something() jika ada( setbadtoval( ($img > $thresh), 0 ) );

Saat menggunakan salah satu fungsi 'proyeksi' di PDL::Ufunc - seperti orover - nilai buruk
dilewati (lihat dokumentasi fungsi-fungsi ini untuk penanganan saat ini (buruk)
kasus ketika semua elemen buruk).

A buruk nilai untuk setiap kencing, dan terkait masalah
An eksperimental opsi "BADVAL_PER_PDL" telah ditambahkan ke perldl.conf untuk memungkinkan per-piddle
nilai-nilai buruk. Dokumentasi belum diperbarui untuk memperhitungkan perubahan ini.

Berikut ini hanya relevan untuk tipe integer, dan untuk tipe floating-point if
"BADVAL_USENAN" tidak disetel saat PDL dibuat.

Saat ini, ada satu nilai buruk untuk setiap tipe data. Kodenya ditulis agar kita bisa
memiliki nilai buruk yang terpisah untuk setiap piddle (disimpan dalam struktur pdl) - ini akan
menghapus masalah saat ini:

pdl> $a = byte( 1, 2, byte->nilai buruk, 4, 5 );
pdl> p $a;
[1 2 255 4 5]
pdl> $a->bendera buruk(1)
pdl> p $a;
[1 2 BURUK 4 5]
pdl> byte->nilai buruk(0);
pdl> p $a;
[1 2 255 4 5]

yaitu nilai buruk dalam $a telah hilang buruk status menggunakan implementasi saat ini. Itu akan
hampir pasti menyebabkan masalah di tempat lain sekalipun!

PENERAPAN RINCIAN

Selama "perl Makefile.PL", file Dasar/Inti/dukungan buruk.p dibuat; file ini
berisi nilai variabel "WITH_BADVAL", "BADVAL_USENAN" dan "BADVAL_PER_PDL",
dan harus digunakan oleh kode yang dieksekusi sebelum PDL::Konfigurasi file dibuat (mis
Dasar/Inti/pdlcore.c.PL. Namun, sebagian besar kode PDL hanya perlu mengakses %PDL::Config
susunan (misalnya Dasar/Buruk/buruk.pd) untuk mengetahui apakah dukungan bernilai buruk diperlukan.

Bendera baru telah ditambahkan ke status piddle - "PDL_BADVAL". Jika tidak disetel, maka
piddle tidak mengandung nilai buruk, sehingga semua kode dukungan dapat diabaikan. Jika diatur, itu
tidak menjamin bahwa nilai-nilai buruk ada, hanya saja mereka harus diperiksa.
Terima kasih kepada Christian, "badflag()" - yang menyetel/menghapus bendera ini (lihat Dasar/Buruk/buruk.pd) -
akan memperbarui SEMUA anak-anak/cucu/dll dari piddle jika statusnya berubah (lihat
"bendera buruk" di Dasar/Buruk/buruk.pd dan "propagate_badflag" di Dasar/Inti/Inti.xs.PL). Ini bukan
jelas apa yang harus dilakukan dengan orang tua: Saya dapat melihat alasan untuk menyebarkan 'set badflag'
permintaan kepada orang tua, tetapi saya pikir seorang anak seharusnya TIDAK dapat menghapus tanda buruk dari a
induk. Ada juga masalah tentang apa yang terjadi ketika Anda mengubah nilai buruk untuk a
kencing.

Struktur "pdl_trans" telah diperluas untuk menyertakan nilai integer, "bvalflag", yang
bertindak sebagai sakelar untuk memberi tahu kode apakah akan menangani nilai buruk atau tidak. Nilai ini ditetapkan
jika ada input piddle yang memiliki flag "PDL_BADVAL" (walaupun kode ini dapat
diganti dengan pengaturan "FindBadStateCode" di pp_def). Logika cek akan didapat
sedikit lebih rumit jika saya mengizinkan rutinitas untuk kembali menggunakan bagian "Kode" untuk
tipe floating-point (yaitu rutinitas dengan "NoBadifNaN => 1" ketika "BADVAL_USENAN" adalah
benar).

Nilai buruk untuk tipe integer sekarang disimpan dalam struktur di dalam Core PDL
struktur - "PDL.bvals" (mis Dasar/Inti/pdlcore.h.PL); lihat juga "typedef badvals" di
Dasar/Inti/pdl.h.PL dan kode BOOT dari Dasar/Inti/Inti.xs.PL dimana nilai
diinisialisasi ke (semoga) nilai yang masuk akal. Lihat PDL/Buruk/buruk.pd untuk rutinitas membaca/menulis untuk
nilai.

Penambahan opsi "BADVAL_PER_PDL" telah menghasilkan perubahan tambahan pada
internal dari piddle. Perubahan ini belum didokumentasikan.

Mengapa tidak membuat a PDL subkelas?
Dukungan untuk nilai-nilai buruk dapat dilakukan sebagai sub-kelas PDL. Keuntungan dari ini
pendekatannya adalah Anda hanya memuat kode untuk menangani nilai buruk jika Anda benar-benar menginginkannya
untuk menggunakannya. Kelemahannya adalah kodenya kemudian dipisahkan: bug apa pun
perbaikan/perbaikan harus dilakukan pada kode dalam dua file berbeda. Dengan saat ini
mendekati kode dalam fungsi "pp_def" yang sama (walaupun masih ada masalah
bahwa bagian "Kode" dan "Kode Buruk" perlu diperbarui).

Default buruk nilai-nilai
Nilai buruk default/asli disetel ke (diambil dari distribusi Starlink):

#termasuk

PDL_Byte == UCHAR_MAX
PDL_Pendek == SHRT_MIN
PDL_Ushort == USHRT_MAX
PDL_Panjang == INT_MIN

Jika "BADVAL_USENAN == 0", maka kami juga memiliki

PDL_Mengambang == -FLT_MAX
PDL_Ganda == -DBL_MAX

jika tidak, semua "NaN", "+Inf", dan "-Inf" dianggap buruk untuk tipe floating-point.
Dalam hal ini, nilai buruk tidak dapat diubah, tidak seperti tipe integer.

Seterpercayaapakah Olymp Trade? Kesimpulan do I perubahan a rutin untuk menangani buruk nilai-nilai?
Contoh dapat ditemukan di sebagian besar *.pd file dalam Dasar/ (dan semoga lebih banyak tempat
segera!). Beberapa logika mungkin tampak agak tidak jelas - itu mungkin karena memang begitu!
Komentar dihargai.

Semua rutinitas harus secara otomatis menyebarkan bendera status buruk ke piddle keluaran, kecuali
Anda menyatakan sebaliknya.

Jika rutin secara eksplisit menangani nilai buruk, Anda harus memberikan opsi ini ke pp_def:

HandleBad => 1

Ini memastikan bahwa variabel yang benar diinisialisasi untuk makro $ISBAD dll. Dia
juga digunakan oleh rutinitas pembuatan dokumen otomatis untuk memberikan informasi default tentang
dukungan nilai buruk dari rutinitas tanpa pengguna harus mengetiknya sendiri (ini adalah
dalam tahap awal).

Untuk menandai rutinitas sebagai TIDAK menangani nilai buruk, gunakan

HandleBad => 0

Kredensial mikro harus menyebabkan rutinitas untuk mencetak peringatan jika mengirim piddles dengan yang buruk
bendera ditetapkan. "Intover" primitif memiliki set ini - karena akan canggung untuk mengonversi -
tapi saya belum mencobanya untuk melihat apakah itu berfungsi.

Jika Anda ingin menangani nilai buruk tetapi tidak mengatur status semua piddle keluaran, atau jika
yang penting cuma satu masukan piddle, trus lihat aturan PP nya
"NewXSFindBadStatus" dan "NewXSCopyBadStatus" dan opsi "pp_def" yang sesuai:

TemukanKode Status Buruk
Secara default, "FindBadStatusCode" membuat kode yang menetapkan "$PRIV(bvalflag)" tergantung pada
status bendera buruk dari input piddles: lihat "findbadstatus" di
Dasar/Gen/PP.pm. Kode yang ditentukan pengguna juga harus menyimpan nilai "bvalflag" di
Variabel "$BADFLAGCACHE()".

SalinKode Status Buruk
Kode default di sini sedikit lebih sederhana daripada "FindBadStatusCode": tanda buruk dari
piddle keluaran disetel jika "$BADFLAGCACHE()" benar setelah kodenya
dievaluasi. Terkadang "CopyBadStatusCode" disetel ke string kosong, dengan
tanggung jawab pengaturan badflag dari piddle output diserahkan ke "BadCode"
bagian (misalnya rutinitas "xxxover" di Dasar/Primitif/primitif.pd).

Sebelum PDL 2.4.3 kami menggunakan "$PRIV(bvalflag)" sebagai ganti "$BADFLAGCACHE()". Ini adalah
berbahaya karena struktur "$PRIV()" tidak dijamin valid pada saat ini di
Kode.

Jika Anda memiliki rutinitas yang ingin Anda gunakan sebagai tempat, lihat rutinitas di
buruk.pd (Atau ops.pd) yang menggunakan opsi "di tempat" untuk melihat bagaimana bendera buruk disebarkan
untuk anak-anak menggunakan opsi "xxxBadStatusCode". Saya memutuskan untuk tidak mengotomatiskan ini sebagai aturan
akan sedikit rumit, karena tidak setiap operasi di tempat perlu menyebarkan bendera buruk
(misalnya fungsi unary).

Jika opsi

HandleBad => 1

diberikan, maka banyak hal terjadi. Untuk tipe integer, kode readdata secara otomatis
membuat variabel yang disebut " _badval", yang berisi nilai buruk untuk itu
piddle (lihat "get_xsdatapdecl()" di Dasar/Gen/PP/PdlParObjs.pm). Namun, jangan kode keras
nama ini ke dalam kode Anda! Alih-alih gunakan makro (terima kasih kepada Tuomas atas sarannya):

'$ISBAD(a(n=>1))' diperluas menjadi '$a(n=>1) == a_badval'
'$BAIK(a())' '$a() != a_badval'
'$SETBAD(bob())' '$bob() = bob_badval'

baik, "$a(...)" diperluas juga. Juga, Anda dapat menggunakan "$" sebelum nama pdl, jika
Anda menginginkannya, tetapi mulai terlihat seperti derau garis - misalnya "$ISGOOD($a())".

Jika Anda menyimpan nilai piddle dalam sebuah variabel -- misalnya "indeks" di irisan.pd -- pengikut
rutinitas berguna:

'$ISBADVAR(c_var,pdl)' 'c_var == pdl_badval'
'$ISGOODVAR(c_var,pdl)' 'c_var != pdl_badval'
'$SETBADVAR(c_var,pdl)' 'c_var = pdl_badval'

Berikut ini telah diperkenalkan, Mereka mungkin perlu bermain-main untuk meningkatkan kemampuan mereka
digunakan.

'$PPISBAD(CHILD,[i]) 'CHILD_physdatap[i] == CHILD_badval'
'$PPISGOOD(CHILD,[i]) 'CHILD_physdatap[i] != CHILD_badval'
'$PPSETBAD(CHILD,[i]) 'CHILD_physdatap[i] = CHILD_badval'

Jika "BADVAL_USENAN" diset, maka akan sedikit berbeda untuk "float" dan "double", di mana kita
anggap "NaN", "+Inf", dan "-Inf" semuanya buruk. Pada kasus ini:

ISBAD menjadi terbatas (piddle) == 0
BAIK terbatas (piddle) != 0
Piddle SETBAD = NaN

di mana nilai untuk NaN dibahas di bawah ini dalam Menangani nilai NaN.

Ini semua berarti bahwa Anda dapat berubah

Kode => '$a() = $b() + $c();'

untuk

BadCode => 'jika ( $ISBAD(b()) || $ISBAD(c()) ) {
$SETBAD(a());
} Else {
$a() = $b() + $c();
}'

meninggalkan Kode apa adanya. PP::PDLCode kemudian akan membuat loop seperti

if ( __trans->bvalflag ) {
threadloop melalui BadCode
} Else {
threadloop di atas Kode
}

(mungkin lebih mudah untuk hanya melihat .xs file untuk melihat apa yang terjadi).

Pergi Luar itu Kode bagian
Mirip dengan "BadCode", ada "BadBackCode", dan "BadRedoDimsCode".

Menangani "EquivCPOffsCode" sedikit berbeda: dengan asumsi bahwa satu-satunya akses
untuk data adalah melalui makro "$EQUIVCPOFFS(i,j)", maka kita dapat secara otomatis membuat 'buruk'
versi itu; lihat aturan "[EquivCPOffsCode]" dan "[Code]" di PDL::PP.

Makro mengakses untuk itu buruk bendera of a kencing
Makro telah disediakan untuk menyediakan akses ke status bendera buruk pdl:

'$PDLSTATEISBAD(a)' -> '($PDL(a)->status & PDL_BADVAL) > 0'
'$PDLSTATEISGOOD(a)' '($PDL(a)->status & PDL_BADVAL) == 0'

'$PDLSTATESETBAD(a)' '$PDL(a)->status |= PDL_BADVAL'
'$PDLSTATESETGOOD(a)' '$PDL(a)->status &= ~PDL_BADVAL'

Untuk digunakan di "xxxxBadStatusCode" (+ hal-hal lain yang masuk ke bagian INIT:) ada:

'$SETPDLSTATEBAD(a)' -> 'a->status |= PDL_BADVAL'
'$SETPDLSTATEGOOD(a)' -> 'a->status &= ~PDL_BADVAL'

'$ISPDLSTATEBAD(a)' -> '((a->status & PDL_BADVAL) > 0)'
'$ISPDLSTATEGOOD(a)' -> '((a->status & PDL_BADVAL) == 0)'

Di PDL 2.4.3 makro "$BADFLAGCACHE()" diperkenalkan untuk digunakan di "FindBadStatusCode" dan
"CopyBadStatusCode".

Penanganan Tidak nilai-nilai
Ada dua masalah:

NaN sebagai nilai buruk
yang dilakukan. Untuk memilih, setel "BADVAL_USENAN" ke 1 di perldl.conf; nilai 0 jatuh
kembali memperlakukan tipe floating-point sama dengan bilangan bulat. Saya perlu melakukan beberapa
tolok ukur untuk melihat mana yang lebih cepat, dan apakah itu tergantung pada mesin (Linux tampaknya
untuk memperlambat lebih dari mesin Sparc saya dalam beberapa tes yang sangat sederhana yang saya lakukan).

Mengabaikan bagian BadCode
yang mana tidak.

Untuk sederhana rutinitas memproses angka floating-point, kita harus membiarkan proses komputer
nilai buruk (yaitu nilai "NaN" dan "Inf") daripada menggunakan kode di "BadCode"
bagian. Banyak rutinitas seperti itu telah diberi label menggunakan "NoBadifNaN => 1"; namun ini adalah
sekarang diabaikan oleh PDL::PP.

Untuk rutinitas ini, kami ingin menggunakan bagian "Kode" jika

piddle tidak memiliki flag yang buruk
tipe datanya adalah float atau double

jika tidak, kami menggunakan bagian "Kode Buruk". Ini adalah JANGAN DITERAPKAN, karena akan membutuhkan
peretasan PP::PDLCode yang masuk akal!

Ada juga masalah bagaimana kita menangani 'pengecualian' - karena "$a = pdl(2) / pdl(0) "
menghasilkan nilai buruk tetapi tidak memperbarui nilai badflag dari piddle. Bisakah kita menangkap
pengecualian, atau apakah kita harus menjebak untuk ini (misalnya mencari "pengecualian" di
Dasar/Ops/ops.pd)?

Memeriksa "Nan", dan "Inf" dilakukan dengan menggunakan panggilan sistem "finite()". Jika Anda menghendaki
tetapkan nilai ke nilai "NaN", bit kode berikut dapat digunakan (ini dapat ditemukan
di keduanya Dasar/Inti/Inti.xs.PL dan Dasar/Buruk/buruk.pd):

/* untuk mesin big-endian */
static union { unsigned char __c[4]; mengapung __d; }
__pdl_nan = { { 0x7f, 0xc0, 0, 0 } };

/* untuk mesin little-endian */
static union { unsigned char __c[4]; mengapung __d; }
__pdl_nan = { { 0, 0, 0xc0, 0x7f } };

Pendekatan ini mungkin harus diganti dengan rutinitas perpustakaan seperti "nan("")" atau
"atof("NaN")".

Untuk mengetahui apakah mesin tertentu adalah big endian, gunakan rutin
"PDL::Inti::Dev::isbigendian()".

APA TENTANG KAMI DOKUMENTASI?

Salah satu kekuatan PDL adalah dokumentasi on-line-nya. Tujuannya adalah menggunakan sistem ini untuk
memberikan informasi tentang bagaimana/jika rutin mendukung nilai buruk: dalam banyak kasus "pp_def()"
berisi semua informasi, jadi penulis fungsi tidak perlu melakukan apa pun di
semua! Untuk kasus ketika ini tidak cukup, ada opsi "BadDoc". Untuk kode
ditulis pada level Perl - yaitu dalam file .pm - gunakan direktif pod "=for bad".

Informasi ini akan tersedia melalui dokumentasi man/pod2man/html. Itu juga
dapat diakses dari shell "perldl" atau "pdl2" - menggunakan perintah "badinfo" - dan
Perintah shell "pdldoc" - menggunakan opsi "-b".

Dukungan ini pada tahap yang sangat awal - yaitu tidak banyak pemikiran yang masuk ke dalamnya: komentar
dipersilakan; perbaikan pada kode yang disukai;) Satu masalah yang canggung adalah untuk *.PM kode:
kamu harus menulis *.pm.PL file yang hanya menyisipkan direktif "= for bad" (+ teks) if
dukungan nilai buruk dikompilasi. Faktanya, ini menyebalkan ketika menangani nilai buruk di
Perl, daripada PDL::PP, level: mungkin saya harus menghapus opsi "WITH_BADVAL"...

ARUS MASALAH

Ada sejumlah area yang membutuhkan pekerjaan, masukan pengguna, atau keduanya! Mereka disebutkan
di tempat lain dalam dokumen ini, tetapi ini hanya untuk memastikan mereka tidak tersesat.

Penangkapan tidak sah matematis operasi
Haruskah kita menambahkan pengecualian ke fungsi di "PDL::Ops" untuk mengatur output buruk untuk out-of-
rentang nilai masukan?

pdl> p log10(pdl(10,100,-1))

Saya ingin yang di atas menghasilkan "[1 2 BURUK]", tetapi ini akan memperlambat operasi pada semua
piddle. Kita bisa memeriksa nilai "NaN"/"Inf" setelah operasi, tapi aku ragu
akan lebih cepat.

integrasi dengan Tidak
Ketika "BADVAL_USENAN" benar, rutinitas di "PDL::Ops" seharusnya jatuh ke
Bagian "Kode" - yaitu jangan gunakan "BadCode" - untuk tipe data "float" dan "double".

Aksi lawan per-piddle buruk nilai-nilai
Saya pikir yang diperlukan hanyalah mengubah rutinitas di "Basic/Core/pdlconv.c.PL", meskipun
pasti ada komplikasi. Itu juga berarti bahwa struktur pdl akan membutuhkan
memiliki variabel untuk menyimpan nilai buruknya, yang berarti ketidakcocokan biner dengan
versi PDL sebelumnya dengan dukungan nilai buruk.

Pada 17 Maret 2006, PDL berisi: eksperimental Opsi konfigurasi "BADVAL_PER_PDL"
yang, jika dipilih, menambahkan nilai buruk per-piddle.

Aliran data of itu bendera buruk
Saat ini perubahan pada bendera buruk disebarkan ke anak-anak dari piddle, tapi mungkin
mereka juga harus diteruskan ke orang tua juga. Dengan munculnya per-piddle bad
nilai yang perlu kita pertimbangkan bagaimana menangani perubahan pada nilai yang digunakan untuk mewakili item yang buruk
juga.

SEGALA SESUATU ELSE

Proses pembangunan telah terpengaruh. File-file berikut sekarang dibuat selama build:

Dasar/Inti/pdlcore.h pdlcore.h.PL
pdlcore.c pdlcore.c.PL
pdlapi.c pdlapi.c.PL
Inti.xs Inti.xs.PL
Inti.pm ​​Inti.pm.PL

Beberapa file baru telah ditambahkan:

Basic/Pod/BadValues.pod (yaitu file ini)

t/buruk.t

Dasar/Buruk/
Dasar/Buruk/Makefile.PL
buruk.pd

dll

TINDAKAN/SARAN

· Lihatlah menggunakan nilai-nilai buruk per-piddle. Akan berarti perubahan pada struktur pdl (yaitu
ketidakcocokan biner) dan rutinitas di "Basic/Core/pdlconv.c.PL" perlu
berubah untuk menangani ini. Kebanyakan rutinitas lainnya harus tidak perlu diubah...

Lihat eksperimental Opsi "BADVAL_PER_PDL".

· apa yang harus dilakukan tentang "$b = pdl(-2); $a = log10($b)" - $a harus disetel buruk, tetapi
saat ini tidak.

· Izinkan operasi di PDL::Ops untuk melewati pemeriksaan nilai buruk saat menggunakan NaN sebagai
nilai buruk dan memproses piddle floating-point. Membutuhkan sedikit pekerjaan yang adil untuk
PDL::PP::PDLCode.

· "$pdl->baddata()" sekarang memperbarui semua anak dari piddle ini juga. Namun, tidak
yakin apa yang harus dilakukan dengan orang tua, karena:

$b = $a->iris();
$b->data buruk(0)

tidak berarti bahwa $a tidak boleh menghapus nilai buruknya. namun, setelah

$b->data buruk(1)

masuk akal untuk berasumsi bahwa orang tua sekarang ditandai sebagai mengandung nilai-nilai buruk.

MUNGKIN Anda hanya dapat menghapus bendera nilai buruk jika Anda BUKAN anak dari orang lain
piddle, sedangkan jika Anda mengatur bendera maka semua anak DAN orang tua harus ditetapkan sebagai
baik?

Demikian pula, jika Anda mengubah nilai buruk dalam piddle, haruskah ini disebarkan ke
orang tua & anak? Atau haruskah Anda hanya dapat melakukan ini di piddle 'tingkat atas'?
Menjijikan...

· siapkan beberapa kode untuk melakukan tolok ukur untuk melihat seberapa banyak hal yang melambat (dan untuk
periksa apakah saya tidak mengacaukan semuanya jika "WITH_BADVAL" adalah 0/undef).

· beberapa nama tidak menarik - saya memikirkan "orig_badvalue()" di
Dasar/Buruk/buruk.pd secara khusus. Setiap saran dihargai.

Gunakan PDL::BadValuesp online menggunakan layanan onworks.net