CMATH

Išversta su http://www.optivec.com/cmfuncs/

Šiame puslapyje aprašoma šių produktų:
CMATH už Visual C++
CMATH už C++ Builder (anksčiau Borland C++)
CMATH už Delphi

1. Įžanga

 

CMATH yra išsami bibliotekos komplekso numeris arithmetics ir matematikos, tiek dekarto ir polinių koordinačių, C/C++ ir Pascal/Delphi, kompiliatoriai. CMATH yra kaip atskiras produktas. Jis taip pat yra įtrauktas į OptiVec paketą.
Visos funkcijos taip pat gali būti vadinamas klasikinis C ir Pascal/Delphi, su tipui būdingų funkcijų pavadinimai (pvz., cf_sin, cd_exp, pe_sqrt), arba C++ ir Delphi su perkrautas funkcijų pavadinimai ir ūkio subjektams (pavyzdžiui, nuodėmės sin, exp, sqrt, operator +; ūkio operator tik C++). Kiek įmanoma, visos funkcijos tos pačios vardus, Pascal/Delphi, versija kaip C/C++ versija.

Aukščiausios greitis, tikslumas ir saugumas yra pasiekta įgyvendinant Asamblėjos kalba (kaip priešprieša parengė arba inline kodas turimų kompleksas C++ klasė bibliotekose). Tik paprastas užduotis, alternatyvūs tiesioginiai C++ funkcijos yra naudojamas C++ versija.

Kiek taikymo sritis CMATH sutampa su kompleksas klasės taikymų Visual C++, C++ Builder (buvęs Borland C++), ir Delphi, CMATH yra aukštos kokybės pakeitimo, dėl pastarosios, kuri yra visai neefektyvus ir netikslūs.

Priešingai nei nurašyta-ir-parengė vadovėlį formulės dauguma kitų galimų sudėtingų bibliotekos (įskaitant tuos, kurie ateina su Visual C++ ir Borland kompiliatoriai), įgyvendinimo CMATH, buvo vadovaujamasi šiomis taisyklėmis:

  1. Be jokių kompromisų, pirmenybė visada teikiama matematiškai teisingą rezultatą, kurių tikslumas reikalavo atitinkamų duomenų tipas. Ypač sudėtingų funkcijų, dėl to būtina labai kruopščiai, gydymas daug skirtingų situacijų. Siekiant šio tikslo, įvairiais atvejais turi būti išskiriami su pedantiškas, priežiūra. (Vadovėlis formulių nereikia gydyti šias situacijas atskirai, nes jie teoriškai manyti, begalinis tikslumas tarpinių rezultatų; faktinis įgyvendinimo, tačiau, tenka dirbti su riboto tikslumo pateikta realaus gyvenimo procesorių.)
  2. Matematinės funkcijos turi būti “saugus” bet kokiomis aplinkybėmis. Jie gali be jokios priežasties tiesiog avarijos, bet turite atlikti tinkamą gydymo klaidos. Tai tiesa, netgi – o galbūt ypač – už, atrodytų, absurdiška argumentus, išskyrus vieną ne numerius INF ir NAN, kuris atsiranda patys, tik dėl rimtų klaidų kitas funkcijas.
  3. Visais įmanomais būdais, didžiausias vykdymo greitis turi būti pasiektas. (Galų gale, jūs ne pirkti jūsų greitą kompiuterio, nieko!)
  4. Programos kodas turi būti taip pat kompaktiškas, kaip įmanoma. Tačiau, kilus konfliktų, greičiau vykdymo greitis yra visada teikiama pirmenybė mažesnių kodas dydžio.

1.1 C/C++ Specifika

Kompleksas C++ klasės ir C structs fComplex ir kt. yra dvejetainis suderinamos tarpusavyje. Šis punktas gali tapti svarbu didelių projektų, sumaišyti su C ir C++ modulius. Esamas C++ kodą, kuris naudoja sudėtingas klasės, bibliotekos, esančios <complex.h>, gali būti paliktas nepakeistas, nes CMATH funkcijų ir duomenų tipų, taip pat yra dvejetainis suderinama su <<complex.h>. Bendroji išimtis yra valstybės funkcija, polar, kuris turėjo būti pakeičiamas magargtoc, nes žodis “polar” dabar reiškia sudėtingas klases polinė koordinačių.
Čia yra išsamų aprašymą, kaip naudotis CMATH jūsų projektams:

1. C++ moduliai, deklaruoti
#include <newcplx.h>
Tada, po šešių kompleksas klases yra šie:
class complex<float>, class complex<double>, class complex<long double>, class polar<float>, class polar<double>, ir class polar<long double>.

Duomenų tipų fComplex, dComplex, eComplex, fPolar, dPolar, ir ePolar yra apibrėžiamas kaip sinonimai šių klasių.
Siekiant išvengti raidė “L” (kuris jau baigėsi-naudoti ilgai ir nepasirašyti ilgas žodis pratęstas yra naudojamas kaip sinonimas ilgai dvigubai Borland C++ versija CMATH. Į MSVC versiją, tai yra sinonimas dvigubai (double), kaip MSVC nepalaiko 80 bitų IEEE reals. Todėl, sudėtingos duomenų tipų pratęstas (extended) tikslumas yra pavadintas eComplex ir ePolar.

2. Jei norite turėti “klasikinis” klasės sudėtinga vyresnio amžiaus spaudai apie Borland C++, jūs turite deklaruoti
#define CMATH_CLASSIC_COMPLEX
prieš (!) įskaitant <newcplx.h>.
Šiuo atveju, tik klasės kompleksas bus apibrėžta ir gauna sinonimas dComplex. Čia jūs neturi prieigos prie sudėtingas skaičius funkcijas float ir a extended tikslumo, ir visas funkcijas polinės koordinatės yra nepasiekiamas, taip pat.

3. Paprastojo-C modulių, jūs negalite būti <newcplx.h>. O, prašome deklaruoti
#include <cmath.h>
Jei naudojate tik vieną lygį, slankiojo kablelio tikslumu, jums gali pageidauti pateikti tik vieną tipą-konkrečios, apima-failus: <cfmath.h>, <cdmath.h>, arba <cemath.h>, atitinkamai.
Lyguma-C įgyvendinimo CMATH grindžiamas šios sąvokos sudėtingų duomenų tipai:
typedef struct { float Re, Im; } fComplex;
typedef struct { double Re, Im; } dComplex;
typedef struct { extended Re, Im; } eComplex;
typedef struct { float Mag, Arg; } fPolar;
typedef struct { double Mag, Arg; } dPolar;
typedef struct { extended Mag, Arg; } ePolar;

Kaip aprašyta pirmiau, duomenų tipas extended yra naudojamas kaip sinonimas long double (Embarcadero/Borland C++ versija) arba du double (MSVC versiją).

4. Sudedamosios dalys C++ klases yra paskelbti viešai. Jie yra pavadintas “Re” ir “Im” dekarto klases, ir “Mag” ir “Arg” polar klases. Tai leidžia juos pasiekti, kaip z.Re, z.Im, p.Mag, or p.Arg a C++ modulius, taip pat lyguma-C modulius.

5. Dėl laiko-kritinių programų, mes rekomenduojame naudoti C, o ne C++ versija CMATH, kaip C/C++ kompiliatoriai rankena structs daug efektyviau nei klasių. Naudoti C versija su savo C++ moduliai, atkreipkite dėmesį į šiuos dalykus:

  • įtraukti <cmath.h>, o ne <newcplx.h>
  • už iniciacijos, priskirti nekilnojamojo/įsivaizduojamas arba Mag/Arg dalys, tiesiogiai (pvz., z.Re = 3; z.Im = 5;) arba naudoti funkcijas fcplx, dcplx, ecplx, fpolr, dpolr, epolr. Kad statybininkai complex(), fComplex(), polar(), fPolar() ir pan. nėra.
  • jei jums padaryti, kad C++ kompiliuoti modulius su <cmath.h> įtraukti, jūs turite pasirinkti tarp skambina CMATH funkcijas pagal jų rūšį-specialūs pavadinimai (pvz., cf_sin, cd_exp), arba jų perkrautas C++ pavadinimai (pvz., sin, exp). Kai kuriais atvejais, jums gali būti priversti naudoti tipo konkrečius vardus, siekiant išspręsti neaiškumus.

1.2 Delphi Specifika

CMATH už Delphi apibrėžia šešis sudėtingas duomenų tipai:
type fComplex = record Re, Im: Single; end;
type dComplex = record Re, Im: Double; end;
type eComplex = record Re, Im: Extended; end;
type fPolar = record Mag, Arg: Float; end;
type dPolar = record Mag, Arg: Double; end;
type ePolar = record Mag, Arg: Extended; end;

Priežastis, kodėl vieno tikslumo tipo gauna vardą, fComplex vietoj sComplex yra tai, kad raidė “s” jau baigėsi, naudojamos ShortInt ir SmallInt, Pascal/Delphi. Taigi, šis pavadinimas yra kilęs nuo C/C++ analogas Single kuris yra float.

Į CMATH-Delphi, duomenų tipai yra dvejetainis suderinama su C/C++ kalbomis.

Tipui būdingų funkcijų pavadinimai yra tokie patys kaip ir paprasto-C versiją. Sintaksė, tačiau yra šiek tiek kitokia, kaip C palaiko kompleksiniai skaičiai (apibrėžiamas kaip structs) kaip grįžti vertės, kadangi Pascal ir anksti Delphi versijas iš pradžių neleido record įrašai bus grąžinti funkcija (tai leidžiama tik Delphi). Taigi, jie yra perduodami kaip var argumentai, sudėtingų funkcijų, pvz.,procedūra cf_sin( var zy:fComplex; zx:fComplex ); 

Į perkrautas funkcijų pavadinimai yra tokie patys kaip ir C++ versija. Čia, rezultatai yra vertinami kaip tikrąją vertes, pvz.
funkcija sin( zx:fComplex ): fComplex;


2. Apžvalgą daugiau Funkcijų CMATH

 

Taip, ji dažnai yra tik fComplex ar fPolar versija funkciją, kuri yra aiškiai nurodyta. Versijas dComplex / dPolar, ir eComplex / ePolar visada tiksliai analogiškas.
Visos funkcijos kalbų, C ir Pascal/Delphi, yra priešdėlis, reiškiantis duomenų tipas, dėl kurių funkcijos veikia:
“cf_” arba “pf_” reiškia vieną tikslumo (argumentai ir grįžti vertės duomenų tipų fComplex, fPolar kartais kartu su float),
“cd_” arba “pd_” stovi dvigubo tikslumo (argumentai ir grįžti vertės duomenų tipų dComplex, dPolar kartais kartu su dvigule), kadangi
“ce_” ir “pe_” reiškia pratęstas-tikslumo funkcijas.

C++ ir Delphi, sinonimai yra apibrėžta už visas šias funkcijas. Sinonimų neturi priešdėlis, nuo duomenų tipo informacija yra netiesiogiai reguliuoja sudarytojas. Į perkrautas funkcijų pavadinimai dažniausiai yra tokie patys kaip rasti sudėtingas direktoriją (jeigu atitinkamos funkcijos egzistuoja). Tačiau atminkite, kad valstybės funkcija polar turėjo būti pakeičiamas magargtoc, kaip pavadinimas “polar” dabar yra rezervuota polar klases.

C++ tik: Jei norite naudoti C funkcija vardus į jūsų C++ moduliai, būtinai <cmath.h>, o ne <newcplx.h>.


2.1. Iniciacijos Kompleksas Numeriai

Taip, mes pažymėti sudėtingas klases pagal jų trumpi vardai, fComplex, fPolar ir kt. C++, jūs galite visada naudoti tą šabloną, nomenklatūros, o ne, rašo “complex<float>” kur “fComplex” parašyta čia, ir taip visų kitų sudėtingų rūšių ir klasių.

Kompleksiniai skaičiai yra parengti pagal atskirai priskirti vertę įsivaizduojamo ir realaus dalys, pvz.:
z.Re = 3.0; z.Im = 5.7;
p.Mag = 8.8; p.Arg = 3.14;

(Žinoma, Pascal/Delphi, priskyrimo operatorius yra parašyta “:=”).
Kita vertus, pats iniciacijos gali būti atliekamas funkcijas fcplx ar fpolr:

C/C++:
z = fcplx( 3.0, 5.7 );
p = fpolr( 4.0, 0.7 );

Delphi:
fcplx( z, 3.0, 5.7 );
fpolr( p, 3.0, 5.7 );

Dėl dvigubo tikslumo kompleksiniai skaičiai, naudoti dcplx ir dpolr ilgą tikslumo kompleksiniai skaičiai, naudoti ecplx ir epolr.


2.2. Duomenų-Tipas Interconversions

Interkonversijų tarp įvairių sudėtingų rūšių yra atliekamas funkcijas:

cftocd,  cdtocf,   cftoce,  cetocf,   cdtoce,  cetocd aukštyn arba žemyn konversijų tikslumą per dekarto-sudėtingas tipai
pftopd,  pdtopf,   pftope,  petopf,   pdtope,  petopd aukštyn arba žemyn konversijų tikslumą per polar-sudėtingas tipai
cftopf,  cftopd,  cftope,
cdtopf,  cdtopd,  cdtope,
cetopf,  cetopd,  cetope
konvertavimas iš stačiakampių į polar kompleksas
pftocf,  pftocd,  pftoce,
pdtocf,  pdtocd,  pdtoce,
petocf,  petocd,  petoce
konvertavimas iš polar į dekarto kompleksas

PERKRAUTAS sąlygas kursą žemyn-konversijos tyliai tvarko nustatymo rezultatas didžiausią vertę įmanoma.
C++ tik:

C++ modulius, yra keletas perkrautas statybininkai kaip alternatyva šias funkcijas:
pagrindinių formų:
fComplex fComplex( float RePart, float ImPart=0 );
fComplex fComplex( dComplex );
fComplex fComplex( eComplex );
fPolar fPolar( float MagPart, float ArgPart=0 );
fPolar fPolar( dPolar );
fPolar fPolar( ePolar );

interkonversijos dekarto <–> polar:
fComplex fComplex( fPolar );
fComplex fComplex( dPolar );
fComplex fComplex( ePolar );
fPolar fPolar( fComplex );
fPolar fPolar( dComplex );
fPolar fPolar( eComplex );

Panašiai, kaip ir statybininkai fComplex() ir fPolar(), taip pat dComplex(), dPolar(), eComplex, ir ePolar() yra perkrautos, todėl versijas atlikti tas pačias užduotis, už klases, dComplex, dPolar, eComplex, ir ePolar, atitinkamai. Kaip minėta pirmiau, PERKRAUTAS sąlygas kursą žemyn-konversijos tyliai tvarko nustatymo rezultatas didžiausią vertę įmanoma.

Speciali konstruktorius už poliarinio numeriai yra
fPolar pf_principal ( fPolar __p );
ir, C++, tik, jos perkrautas forma du atskiri nekilnojamojo įėjimų skaičius
fPolar principal(  float Mag, float Arg );
Šios funkcijos sumažinti įvesties Arg asortimentą –p < Arg <= +p. Tikriausiai prisimenate, kad kiekvieną sudėtingą skaičius yra begalinis skaičius atstovybės polinė koordinačių, su kampais skiriasi sveikasis skaičius dalijasi iš 2 p. Atstovavimas su –p < Arg <= +p yra vadinamas pagrindinis vertę.
Prašome atkreipti dėmesį, kad tai yra tik polar funkcijas, sumažinti išėjimo į pagrindinę vertę. Visi kiti priima ir grąžina argumentų, kurių kampai gali nepatenka į šį intervalą.

Konvertavimas tarp dekarto ir poliariniai formatu apima transcedental funkcijas ir yra, todėl gana daug laiko. Tiesa, kad multiplications yra greičiau polinė koordinačių, kadangi papildymai yra daug greičiau Dekarto. Skirtumas, tačiau yra tiek daug mažesnės nei išlaidos pereiti atgal ir pirmyn tarp įvairių pareiškimų, kad mes rekomenduojame jums likti apskritai su dekarto formatu. Tik tokiais atvejais, perskaičiavimo tikrai prasminga:

  1. Jūs turite tik multiplications ir susijusios matematikos funkcijos (pvz., square, sqrt, ipow). Tada, jūs turėtumėte pradėti su polinė koordinačių.
  2. Jūs turite skambinti ir sudėtingas eksponentinė funkcija. Šiuo atveju, cf_exptop atneša jums į polinė koordinačių labai natūraliu būdu.
  3. Jūs esate polinė koordinačių ir turi apskaičiuoti logaritmas. Šiuo atveju, pf_logtoc (ar panašiai pf_log2toc, pf_log10toc) atneša jums “žemyn”, kad dekarto atstovavimo.

2.3 Pagrindiniai Sudėtingas Operacijas

Šias pagrindines sudėtingų operacijų yra apibrėžta CMATH:

dekarto C/Pascal/Delphi funkcija polar C/Pascal/Delphi funkcija perkrautas C++/Delphi  funkcija paaiškinimas
cf_conj pf_conj conj kompleksas-konjugato forma
cf_neg pf_neg neg (arba -) neigimą
cf_real pf_real real gavyba tikra dalis
cf_imag pf_imag imag gavyba įsivaizduojama dalis
cf_magargtoc N.A. magargtoc konversijos yra polinės koordinatės, įrašytas kaip atskiras nekilnojamojo numeriai, į dekarto formatas
N.A. pf_reimtop reimtop konversijos sudėtingų koordinates, įrašytas kaip atskiras nekilnojamojo numeriai, į poliariniai formatu
cf_abs pf_abs abs absoliuti vertė (dydis rodykle kompleksas plokštumos; tai traktuojama kaip matematika funkcija su klaidų)
cf_arg pf_arg arg argumentas (kampo rodykle kompleksas plokštumoje)
cf_norm pf_norm norm norm (čia apibrėžiama, kaip aikštėje absoliuti vertė)
N.A. pf_principal principal pagrindinė vertė, su –p < Arg <= +p

(Dvigubo ir pratęstas-tikslumo versijos yra visiškai analogiškas cf_ / pf_ versija)

2.4 Aritmetines Operacijas

Tik C++ ir Delphi nuo 2006 m. versija: Šie operatoriai yra visų trijų stačiakampių kompleksas klases:
    +   –   *   /   +=   -=   *=   /=   ==   !=
Polar kompleksas klases, mes turime:
    *   /   *=    /=    ==    !=
Šie subjektai, taip pat yra “mišri” argumentai, kai vienas argumentas yra sudėtingas, kito nekilnojamojo ir jei argumentai yra įvairių slankiojo kablelio tikslumas.

 

Delphi tik: Be to, šie perkrautas funkcijų, galima naudoti aritmetines operacijas:
add     sub     mul     divide
Jie dirba už du sudėtingus argumentus ar vieną sudėtingą ir vieno realaus argumento.

Be to, visi aritmetines operacijas kompleksinių skaičių yra įgyvendinamas funkcijas, kurias iš tikrųjų teikti veiksmingą įgyvendinimą:

Dekarto Polar
cf_add N.A. be to dviejų kompleksinių skaičių
cf_addRe N.A. be to sudėtingas skaičius, o realusis skaičius
cf_sub N.A. atimti iš dviejų kompleksinių skaičių (pirmas operandas minus antrojo operando)
cf_subRe N.A. atimtis realus skaičius nuo sudėtingas skaičius
cf_subrRe N.A. atimtis sudėtingas skaičius nuo realaus skaičius
cf_mul pf_mul daugyba iš dviejų kompleksinių skaičių
cf_mulRe pf_mulRe dauginimasis sudėtingas skaičius, o realusis skaičius
cf_div pf_div dalyba iš dviejų kompleksinių skaičių (pirmas operandas, padalytas antrojo operando)
cf_divRe pf_divRe skyriaus sudėtingas skaičius, kurį realus skaičius
cf_divrRe pf_divrRe padalinys realusis skaičius sudėtingas skaičius

(panašiai dvigubai ir pratęstas-tikslumo versijos)

Priskyrimo operatorius”=” arba “:=” yra vienintelis operatorius apibrėžiamas taip pat paprasta-C, kompleksiniai skaičiai.

2.5 Matematinių Funkcijų

CMATH yra visi matematinės funkcijos jums būtų rasti sudėtingas direktoriją C++, kartu su keletą papildomų funkcijų:

dekarto C/Pascal/Delphi funkcija polar C/Pascal/Delphi funkcija perkrautas C++/Delphi funkcija formulė paaiškinimas
cf_abs pf_abs abs ry = | zx | absoliuti vertė
cf_acos N.A. acos zy = acos( zx ) arcus kosinusą funkcija
cf_asin N.A. asin zy = asin( zx ) arcus sine funkcija
cf_atan N.A. atan zy = atan( zx ) arcus liečiančios funkcija
cf_cos N.A. cos zy = cos( zx ) kosinusą
cf_cosh N.A. cosh zy = cosh( zx ) hiperbolinį kosinusą
cf_cubic pf_cubic cubic zy = zx3 trečioji galia
cf_exp cf_exptop exp zy = exp( zx ) eksponentinė funkcija
cf_inv pf_inv inv zy = 1.0 / zx atvirkštinis
cf_ipow pf_ipow ipow zy = zxn sveikasis galia
cf_ln pf_lntoc ln zy = ln( zx ) natūralusis logaritmas
cf_log pf_logtoc log zy = ln( zx ) identiškas cf_ln,  pf_lntoc,  ln
cf_log2 pf_log2toc log2 zy = lb( zx ) dvejetainis logaritmas
cf_log10 pf_log10toc log10 zy = lg( zx ) dekadinis logaritmas
cf_pow N.A. pow zy = zxzexp savavališkai galia
cf_powReBase N.A. pow, powReBase zy = rzx nekilnojamojo bazės kompleksas galia
cf_powReExpo pf_powReExpo pow, powReExpo zy = zxr reali valdžia komplekso bazės
cf_quartic pf_quartic quartic zy = zx4 ketvirtoji galia
cf_sin N.A. sin zy = sin( zx ) sine
cf_sinh N.A. sinh zy = sinh( zx ) hiperbolinės sine
cf_square pf_square square zy = zx2 kvadratinių
cf_sqrt pf_sqrt sqrt zy = sqrt( zx ) kvadratinė šaknis
cf_tan N.A. tan zy = tan( zx ) tangentinis
cf_tanh N.A. tanh zy = tanh( zx ) hiperbolinės liečiančios

Kaip minėta, eksponentinis ir logaritmų funkcijas, suteikia natūralų perėjimą nuo dekarto ir polinės koordinatės. Nors yra exp ir log funkcijas fComplex kaip argumentas ir kaip grįžti vertė, cf_exptop trunka fComplex argumentas ir grįžta fPolar. Priešinga kryptimi, pf_logtoc trunka fPolar argumentas ir grįžta fComplex.


3. Klaidų Valdymas

 

3.1 Bendrosios Klaidų Sudėtingų Funkcijų

Klaida tvarkymo sudėtingas funkcijas, laikosi taisyklių dirba, paprastai taip pat už realius skaičius, funkcijos ir operacijos. Visas aritmetines operacijas, dizainas algoritmai pašalina pavojų gedimo dėl netinkamų tarpiniai rezultatai. Perpildyta ar kitaip nereguliarus galutinius rezultatus, tačiau bus aparatūros nutraukti generuojamas ir, kaip pasekmė, programą nutraukti.

Priešingai nei aritmetines operacijas, visas matematines funkcijas atlikti stora klaidų tikrinimas. Visi klaidų pranešimai galiausiai sugeneruotas naudoti C/Pascal pavardė (o ne perkrautos C++/Delphi pavadinimas) sutrikusi funkcija.

3.1.1 C/C++ Specifika

Visi klaidų sąlygos CMATH matematikos funkcijos yra tvarkomi senamadiškas, bet labiausiai lankstus ir efektyvus būdas per _matherr (fComplex ir dComplex funkcijas) ir _matherrl (eComplex funkcijas; 32-bitų Borland C++ tik). Re arba Mag dalis kompleksinio argumento, todėl klaidos yra saugoma e->x ir Im arba Arg dalis e->y.

3.1.2 Pascal/Delphi Specifiką

Kaip CMATH rankenos slankiojo kablelio klaidų sudėtingas matematikos funkcijos yra apibrėžtos ryšį su V_setFPErrorHandling. Keletas iš anksto nustatytų konstantos fperrXXX yra statybos norimą klaidų-tvarkymo režimas:

Pastovi Vertė Reikšmė
fperrIgnore 0 Ignoruoti visus slankiojo kablelio klaidas: jais tvarkytis tyliai, nereikia spausdinti pranešimą, toliau programos vykdymo
fperrNoteDOMAIN $0001 Spausdinti pranešimą atveju DOMAIN klaida
fperrNoteSING $0002 Spausdinti pranešimą atveju SING klaida
fperrNoteOVERFLOW $0003 Spausdinti pranešimą, kai OVERFLOW klaida
fperrNoteTLOSS $0004 Spausdinti pranešimą atveju TLOSS klaida
fperrAbortDOMAIN $0101 Nutraukti programos atveju DOMAIN klaida
fperrAbortSING $0202 Nutraukti programos atveju SING klaida
fperrAbortOVERFLOW $0303 Nutraukti programos atveju dėl OVERFLOW klaida
fperrAbortTLOSS $0404 Nutraukti programos atveju TLOSS klaida
fperrDefaultHandling $0107 Pat kaip fperrAbortDOMAIN ar fperrNoteSING ar fperrNoteOVERFLOW

Pvz.:
V_setFPErrorHandling( fperrAbortDOMAIN + fperrAbortSING + fperrAbortOVERFLOW + fperrNoteTLOSS );
Šiame pavyzdyje, programos vykdymas bus nutrauktas (su atitinkamą pranešimą) jei labai rimtų klaidų, DOMAIN ir SING. Jei OVERFLOW ir TLOSS klaidų, įspėjimas bus rodomas, bet programos vykdymas bus tęsiamas su default rezultatus, nustatyti atitinkamas funkcijas, kai įvyksta klaida. Pasikartojantis įvykis to paties tipo klaidos per vieną ir tą pačią funkciją, bus tik vieną pranešimą generuojamas. Vėliau klaidos bus elgiamasi tyliai.

3.2 Rašymo Klaidos Pranešimus į Failą

Funkcija V_setErrorEventFile suteikia galimybę nuspręsti, jei norite, kad jūsų klaidų pranešimai rodomi ekrane ir/ar žurnalą. Šią funkciją turi kaip argumentai norimą vardą savo renginį failą ir pereiti pavadintas ScreenAndFile, kuri nusprendžia jei norite turėti klaidų pranešimai spausdinti vienu metu į failą ir ant ekrano (ScreenAndFile = TRUE (ne nulis)) ar tik į failą (ScreenAndFile = FALSE (0)).


4. Sintaksė Nuoroda

Išskyrus duomenų tipo konvertavimo funkcijas, tik float / fComplex / fPolar sintaksė yra suteikta. Sintaksės funkcijas du kartus pratęstas ir patikslinta paraiškų yra visiškai analogiškas.
Jei pasirinkote “klasikinis” klasės kompleksas, tai taip pat yra panašus. Tiesiog pakeiskite “float” iki “double” ir “fComplex” iki “complex“. Ne polar funkcijų yra “klasikinis” klasės kompleksas, nei daryti bet kokio tipo liejimo operatorių ir interconversion veikia, jei yra tik vienas tipas.

4.1 Paprastas-C, Pascal/Delphi Funkcijos

Funkcijų dvigubo / dComplex / dPolar ir pratęsė / eComplex / ePolar tikslumo, priešdėlių yra cd_, pd_, ce_, ir pe_, atitinkamai.

float cf_abs( fComplex __z );
function cf_abs( zx:fComplex ): Single;
float pf_abs( fPolar __p );
function pf_abs( px:fPolar ): Single;

fComplex cf_acos( fComplex __z );
procedure cf_acos( var zy:fComplex; zx:fComplex );

fComplex cf_add( fComplex __x, fComplex __y );
procedure cf_add( var zz:fComplex; zx, zy:fComplex );

fComplex cf_addRe( fComplex __x, float __yRe );
procedure cf_addRe( var zz:fComplex; zx:fComplex; yRe:Single );

float cf_arg( fComplex __z );
function cf_arg( zx:fComplex ): Single;

float pf_arg( fPolar __z );
function pf_arg( px:fPolar ): Single;

fComplex cf_asin( fComplex __z );
procedure cf_asin( var zy:fComplex; zx:fComplex );

fComplex cf_atan( fComplex __z );
procedure cf_atan( var zy:fComplex; zx:fComplex );

eComplex cdtoce( dComplex __zd );
procedure cdtoce( var zy:eComplex; zx:dComplex );

fComplex cdtocf( dComplex __zd );
procedure cdtocf( var zy:fComplex; zx:dComplex );

dPolar cdtopd( dComplex __zd );
procedure cdtopd( var py:dPolar; zx:eComplex );

ePolar cdtope( dComplex __zd );
procedure cdtope( var py:ePolar; zx:eComplex );

fPolar cdtopf( dComplex __zd );
procedure cdtope( var py:fPolar; zx:eComplex );

dComplex cetocd( eComplex __ze );
procedure cetocd( var zy:dComplex; zx:eComplex );

fComplex cetocf( eComplex __ze );
procedure cetocf( var zy:fComplex; zx:eComplex );

dPolar cetopd( eComplex __ze );
procedure cetopd( var py:dPolar; zx:eComplex );

ePolar cetope( eComplex __ze );
procedure cetope( var py:ePolar; zx:eComplex );

fPolar cetopf( eComplex __ze );
procedure cetopf( var py:fPolar; zx:eComplex );

dComplex cftocd( fComplex __zf );
procedure cftocd( var zy:dComplex; zx:fComplex );

eComplex cftoce( fComplex __zf );
procedure cftoce( var zy:eComplex; zx:fComplex );

dPolar cftopd( fComplex __zf );
procedure cftopd( var py:dPolar; zx:fComplex );

ePolar cftope( fComplex __zf );
procedure cftope( var py:ePolar; zx:fComplex );

fPolar cftopf( fComplex __zf );
procedure cftopf( var py:fPolar; zx:fComplex );

fComplex cf_conj( fComplex __z );
procedure cf_conj( var zy:fComplex; zx:fComplex );

fPolar pf_conj( fPolar __p );
procedure pf_conj( var py:fPolar; px:fPolar );

fComplex cf_cos( fComplex __z );
procedure cf_cos( var zy:fComplex; zx:fComplex );

fComplex cf_cosh( fComplex __z );
procedure cf_cosh( var zy:fComplex; zx:fComplex );

fComplex cf_cubic( fComplex __z );
procedure cf_cubic( var zy:fComplex; zx:fComplex );

fPolar pf_cubic( fPolar __p );
procedure pf_cubic( var py:fPolar; px:fPolar );

fComplex cf_div( fComplex __x, fComplex __y );
procedure cf_div( var zz:fComplex; zx, zy:fComplex );

fPolar pf_div( fPolar __x, fPolar __y );
procedure pf_div( var pz:fPolar; px, py:fPolar );

fComplex cf_divRe( fComplex __x, float __yRe ); /* x / yRe */
procedure cf_divRe( var zz:fComplex; zx:fComplex; yRe:Single );

fPolar pf_divRe( fPolar __x, float __yRe ); /* x / yRe */
procedure pf_divRe( var pz:fPolar; px:fPolar; yRe:Single );

fComplex cf_divrRe( fComplex __x, float __yRe ); /* yRe / x */
procedure cf_divrRe( var zz:fComplex; zx:fComplex; yRe:Single );

fPolar pf_divrRe( fPolar __x, float __yRe ); /* yRe / x */
procedure pf_divrRe( var pz:fPolar; px:fPolar; yRe:Single );

fComplex cf_exp( fComplex __z );
procedure cf_exp( var zy:fComplex; zx:fComplex );

fPolar cf_exptop( fComplex __z );
procedure cf_exptop( var py:fPolar; zx:fComplex );

fComplex fcplx( float __ReVal, float __ImVal);
procedure fcplx( var zy:fComplex; xRe, xIm:Single );

fPolar fpolr( float __MagVal, float __ArgVal);
procedure fpolr( var py:fPolar; xMag, xArg:Single );

float cf_imag( fComplex __z );
function cf_imag( zx:fComplex ): Single;

float pf_imag( fPolar __p );
function pf_imag( px:fPolar ): Single;

fComplex cf_inv( fComplex __z );
procedure cf_inv( var zy:fComplex; zx:fComplex );

fPolar pf_inv( fPolar __p );
procedure pf_inv( var py:fPolar; zx:fComplex );

fComplex cf_ipow( fComplex __z, int __exponent );
procedure cf_ipow( var zy:fComplex; zx:fComplex; exponent:Integer );

fPolar pf_ipow( fPolar __p, int __exponent );
procedure pf_ipow( var py:fPolar; px:fPolar; exponent:Integer );

fComplex cf_ln( fComplex __z );
procedure cf_ln( var zy:fComplex; zx:fComplex );

fComplex pf_lntoc( fPolar __p );
procedure pf_lntoc( var zy:fComplex; zx:fPolar );

fComplex cf_log( fComplex __z );
procedure cf_log( var zy:fComplex; zx:fComplex );

fComplex pf_logtoc( fPolar __p );
procedure pf_logtoc( var zy:fComplex; zx:fPolar );

fComplex cf_log2( fComplex __z );
procedure cf_log2( var zy:fComplex; zx:fComplex );

fComplex pf_log2toc( fPolar __p );
procedure pf_log2toc( var zy:fComplex; zx:fPolar );

fComplex cf_log10( fComplex __z );
procedure cf_log10( var zy:fComplex; zx:fComplex );

fComplex pf_log10toc( fPolar __p );
procedure pf_log10toc( var zy:fComplex; zx:fPolar );

fComplex cf_magargtoc( float __mag, float __angle );
procedure cf_magargtoc( var zy:fComplex; mag, angle:Single );

fComplex cf_mul( fComplex __x, fComplex __y );
procedure cf_mul( var zz:fComplex; zx, zy:fComplex );

fPolar pf_mul( fPolar __x, fPolar __y );
procedure pf_mul( var zz:fPolar; zx, zy:fPolar );

fComplex cf_mulRe( fComplex __x, float __yRe );
procedure cf_mulRe( var zz:fComplex; zx:fComplex; yRe:Single );

fPolar pf_mulRe( fPolar __x, float __yRe );
procedure pf_mulRe( var zz:fPolar; zx:fPolar; yRe:Single );

fComplex cf_neg( fComplex __z );
procedure cf_neg( var zy:fComplex; zx:fComplex );

fPolar pf_neg( fPolar __p );
procedure pf_neg( var py:fPolar; px:fPolar );

float cf_norm( fComplex __z );
function cf_norm( zx:fComplex ): Single;

float pf_norm( fPolar __p );
function pf_norm( px:fPolar ): Single;

dComplex pdtocd( dPolar __pd );
procedure pdtocd( var zy:dComplex; px:dPolar );

eComplex pdtoce( dPolar __pd );
procedure pdtoce( var zy:eComplex; px:dPolar );

fComplex pdtocf( dPolar __pd );
procedure pdtocf( var zy:fComplex; px:dPolar );

ePolar pdtope( dPolar __pd );
procedure pdtope( var zy:ePolar; zx:dPolar );

fPolar pdtopf( dPolar __pd );
procedure pdtopf( var zy:fPolar; zx:dPolar );

dComplex petocd( ePolar __pe );
procedure petocd( var zy:dComplex; px:ePolar );

eComplex petoce( ePolar __pe );
procedure petoce( var zy:eComplex; px:ePolar );

fComplex petocf( ePolar __pe );
procedure petocf( var zy:fComplex; px:ePolar );

dPolar petopd( ePolar __pe );
procedure petopd( var zy:dPolar; zx:ePolar );

fPolar petopf( ePolar __pe );
procedure petopf( var zy:fPolar; zx:ePolar );

dComplex pftocd( fPolar __pf );
procedure pftocd( var zy:dComplex; px:fPolar );

eComplex pftoce( fPolar __pf );
procedure pftoce( var zy:eComplex; px:fPolar );

fComplex pftocf( fPolar __pf );
procedure pftocf( var zy:fComplex; px:fPolar );

dPolar pftopd( fPolar __pf );
procedure pftopd( var zy:dPolar; zx:fPolar );

ePolar pftope( fPolar __pf );
procedure pftope( var zy:ePolar; zx:fPolar );

fComplex cf_polar( float mag, float arg ); /* same as cf_magargtoc */
procedure cf_polar( var zy:fComplex; mag, arg:Single );

fComplex cf_pow( fComplex __base, fComplex __exponent );
procedure cf_pow( var zy:fComplex; zx:fComplex; exponent:Integer );

fComplex cf_powReBase( float __base, fComplex __exponent );
procedure cf_powReBase( var zy:fComplex; base:Single; exponent:fComplex );

fComplex cf_powReExpo( fComplex __base, float __exponent );
procedure cf_powReExpo( var zy:fComplex; zx:fComplex; exponent:Single );

fPolar pf_powReExpo( fPolar __base, float __exponent );
procedure pf_powReExpo( var py:fPolar; px:fPolar; exponent:Single );

fComplex cf_quartic( fComplex __z );
procedure cf_quartic( var zy:fComplex; zx:fComplex );

fPolar pf_quartic( fPolar __p );
procedure pf_quartic( var py:fPolar; zx:fPolar );

float cf_real( fComplex __z );
function cf_real( zx:fComplex ): Single;

float pf_real( fPolar __p );
function pf_real( px:fPolar ): Single;

fComplex cf_sin( fComplex __z );
procedure cf_sin( var zy:fComplex; zx:fComplex );

fComplex cf_sinh( fComplex __z );
procedure cf_sinh( var zy:fComplex; zx:fComplex );

fComplex cf_square( fComplex __z );
procedure cf_square( var zy:fComplex; zx:fComplex );

fPolar pf_square( fPolar __p );
procedure pf_square( var py:fPolar; zx:fPolar );

fComplex cf_sqrt( fComplex __z );
procedure cf_sqrt( var zy:fComplex; zx:fComplex );

fPolar pf_sqrt( fPolar __p );
procedure pf_sqrt( var py:fPolar; px:fPolar );

fComplex cf_sub( fComplex __x, fComplex __y );
procedure cf_sub( var zz:fComplex; zx, zy:fComplex );

fComplex cf_subRe( fComplex __x, float __yRe ); /* x – yRe */
procedure cf_subRe( var zz:fComplex; zx:fComplex; yRe:Single );

fComplex cf_subrRe( fComplex __x, float __yRe ); /* yRe – x */
procedure cf_subrRe( var zz:fComplex; zx:fComplex; yRe:Single );

fComplex cf_tan( fComplex __z );
procedure cf_tan( var zy:fComplex; zx:fComplex );

fComplex cf_tanh( fComplex __z );
procedure cf_tanh( var zy:fComplex; zx:fComplex );

4.2 Perkrautas C++/Delphi Funkcijos

float abs( fComplex _z );
function abs( zx:fComplex ): Single;

float abs( fPolar _p );
function abs( px:fPolar ): Single;

fComplex acos( fComplex _z );
function acos( zx:fComplex ): fComplex;

function add( zx, zy:fComplex ): fComplex;
function add( zx:fComplex; yRe:Single ): fComplex;
function add( yRe:Single; zx:fComplex ): fComplex;
function addRe( zx:fComplex; yRe:Single ): fComplex;

float arg( fComplex _z );
function arg( zx:fComplex ): Single;

float arg( fPolar _p );
function arg( px:fPolar ): Single;

fComplex asin( fComplex _z );
function asin( zx:fComplex ): fComplex;

fComplex atan( fComplex _z );
function atan( zx:fComplex ): fComplex;

fComplex conj( fComplex _z );
function conj( zx:fComplex ): fComplex;

fPolar conj( fPolar _p );
function conj( px:fPolar ): fPolar;

fComplex cos( fComplex _z );
function cos( zx:fComplex ): fComplex;

fComplex cosh( fComplex _z );
function cosh( zx:fComplex ): fComplex;

fComplex cubic( fComplex _z );
function cubic( zx:fComplex ): fComplex;

fPolar cubic( fPolar _p );
function cubic( px:fPolar ): fPolar;

function divide( zx, zy:fComplex ): fComplex;
function divide( zx:fComplex; yRe:Single ): fComplex;
function divide( yRe:Single; zx:fComplex ): fComplex;
function divide( px, py:fPolar ): fPolar;
function divide( px:fPolar; yRe:Single ): fPolar;
function divide( yRe:Single; px:fPolar ): fPolar;

function divRe( zx:fComplex; yRe:Single ): fComplex;
function divRe( px:fPolar; yRe:Single ): fPolar;
function divrRe( zx:fComplex; yRe:Single ): fComplex;
function divrRe( px:fPolar; yRe:Single ): fPolar;

fComplex exp( fComplex _z );
function exp( zx:fComplex ): fComplex;

fPolar exptop( fComplex _z );
function exptop( zx:fComplex ): fPolar;

fComplex fComplex( float Re_part, float Im_part=0 );
fComplex fComplex( dComplex cd );
fComplex fComplex( eComplex ce ); // type-casting constructors
fComplex fComplex( fPolar pf ); // interconversion from polar
fComplex fComplex( dPolar pd );
fComplex fComplex( ePolar pe );

float imag(); // to be used as zim = z.imag();
float imag( fComplex _z ); // to be used as zim = imag( z );
function imag( zx:fComplex ): Single;

float imag( fPolar _p );
function imag( px:fPolar ): Single;
fComplex inv( fComplex _z );
function inv( zx:fComplex ): fComplex;

fPolar inv( fPolar _p );
function inv( px:fPolar ): fPolar;

fComplex ipow( fComplex __base, int __expon );
function ipow( zx:fComplex; exponent:Integer ): fComplex;

fPolar ipow( fPolar __base, int __expon );
function ipow( px:fPolar; exponent:Integer ): fPolar;

fComplex ln( fComplex _z );
function ln( zx:fComplex ): fComplex;

fComplex lntoc( fPolar _p );
function lntoc( px:fPolar ): fComplex;

fComplex log( fComplex _z );
function log( zx:fComplex ): fComplex;

fComplex logtoc( fPolar _p );
function logtoc( px:fPolar ): fComplex;

fComplex log2( fComplex _z );
function log2( zx:fComplex ): fComplex;

fComplex log2toc( fPolar _p );
function log2toc( px:fPolar ): fComplex;

fComplex log10( fComplex _z );
function log10( zx:fComplex ): fComplex;

fComplex log10toc( fPolar _p );
function log10toc( px:fPolar ): fComplex;

fComplex magargtoc( float _mag, float _angle );
function magargtoc( mag, angle:Single ): fComplex;

function mul( zx, zy:fComplex ): fComplex;
function mul( zx:fComplex; yRe:Single ): fComplex;
function mul( yRe:Single; zx:fComplex ): fComplex;
function mul( px, py:fPolar ): fPolar;
function mul( px:fPolar; yRe:Single ): fPolar;
function mul( yRe:Single; px:fPolar ): fPolar;

function mulRe( zx:fComplex; yRe:Single ): fComplex;
function mulRe( px:fPolar; yRe:Single ): fPolar;

fComplex neg( fComplex _z );
function neg( zx:fComplex ): fComplex;

fPolar neg( fPolar _p );
function neg( px:fPolar ): fPolar;

float norm( fComplex _z );
function norm( zx:fComplex ): Single;

float norm( fPolar _p );
function norm( px:fPolar ): Single;

fComplex pow( fComplex __base, fComplex __expon);
fComplex pow( float __base, fComplex __expon);
fComplex pow( fComplex __base, float __expon );
function pow( zx, exponent:fComplex ): fComplex;
function pow( zx:fComplex; exponent:Single ): fComplex;
function pow( base:Single; exponent:fComplex ): fComplex;
function pow( px:fPolar; exponent:Single ): fPolar;

fComplex powReBase( float __base, fComplex __expon );
function powReBase( base:Single; exponent:fComplex ): fComplex;

fComplex powReExpo( fComplex __base, float __expon );
function powReExpo( zx:fComplex; exponent:Single ): fComplex;

fPolar powReExpo( fPolar __base, float __expon );
function powReExpo( px:fPolar; exponent:Single ): fPolar;

fPolar principal( fPolar _p );
fPolar principal( floag __mag, float __arg );
function principal( px:fPolar ): fPolar;

fComplex quartic( fComplex _z );
function quartic( zx:fComplex ): fComplex;

fPolar quartic( fPolar _p );
function quartic( px:fPolar ): fPolar;

float z.real(); // to be used as zre = z.real();
float real( fComplex _z ); // to be used as zre = real ( _z );
function real( zx:fComplex ): Single;

float real( fPolar _p );
function real( px:fPolar ): Single;

fPolar reimtop( float _re, float _im );
function reimtop( re, im:Single ): fPolar;

fComplex sin( fComplex _z );
function sin( zx:fComplex ): fComplex;

fComplex sinh( fComplex _z );
function sinh( zx:fComplex ): fComplex;

fComplex sqrt( fComplex _z );
function sqrt( zx:fComplex ): fComplex;

fPolar sqrt( fPolar _p );
function sqrt( px:fPolar ): fPolar;

fComplex square( fComplex _z );
function square( zx:fComplex ): fComplex;

fPolar square( fPolar _z );
function square( px:fPolar ): fPolar;

function sub( zx, zy:fComplex ): fComplex;
function sub( zx:fComplex; yRe:Single ): fComplex;
function sub( yRe:Single; zx:fComplex ): fComplex;
function subRe( zx:fComplex; yRe:Single ): fComplex;
function subrRe( zx:fComplex; yRe:Single ): fComplex;

fComplex tan( fComplex _z );
function tan( zx:fComplex ): fComplex;

fComplex tanh( fComplex _z );
function tanh( zx:fComplex ): fComplex;

 

Grįžti į pagrindinį

Leave a Reply

Your email address will not be published. Required fields are marked *