Global bondwire::getProperties (void)

check values

Global bondwire::resistance (const nr_double_t f) const

Offer other resistance model for instance exponential decay and bessel function exact computation. But I do not know it is worth the effort.

Factorise the resistance model.

Global cbesselj_smallarg (unsigned int n, nr_complex_t z)

Not really adapted to high order therefore we do not check overflow for n >> 1

File constants.h

Create a material header

Global correctionfactor (const nr_double_t f, const nr_double_t d, const nr_double_t rho, const nr_double_t mur)

Check domain validity for round C factor.

Global cpwline::ellipke (nr_double_t, nr_double_t &, nr_double_t &)

move to common math

Global deg (x)

Better as static inline

Rename as rad2deg

Global degree (x)

Better as static inline

Rename as celcius2kelvin

Global EgSchottky

What kind of metal (ideal, real, gold)?

Global GMin

move these simulator constants and macros elsewhere.

Define and document

Global Hp

Add h bar ( $h/(2\pi)$ )

Global M_LIMEXP

What is it?

Namespace qucs

test if inline indeed performace improves (optimization flags should inline them anyway)

Global qucs::abs (matrix a)

add abs in place

a is const

Global qucs::adjoint (matrix a)

add adjoint in place

Do not lazy and avoid conj and transpose copy

a is const

Global qucs::arg (matrix a)

add arg in place

a is const

Global qucs::asech (const nr_complex_t z)

for symetry reason implement sech

Global qucs::atos (matrix a, nr_complex_t z1, nr_complex_t z2)

a, z1, z2 const

Global qucs::cbesselj_smallarg (unsigned int n, nr_complex_t z)

Not really adapted to high order therefore we do not check overflow for n >> 1

Global qucs::cofactor (matrix a, int u, int v)

((u + v) & 1) is cryptic use (u + v)% 2

#ifdef 0

static?

Global qucs::conj (matrix a)

add conj in place

a is const

Global qucs::cstocy (matrix cs, matrix y)

cs, y const

Global qucs::cstocz (matrix cs, matrix z)

cs, z const

Global qucs::cytocs (matrix cy, matrix s)

cy s const

Global qucs::cytocz (matrix cy, matrix z)

cs, z const

Global qucs::cztocs (matrix cz, matrix s)

cz, s const

Global qucs::cztocy (matrix cz, matrix y)

cs, y const

Global qucs::det (matrix a)

a const?

Global qucs::detGauss (matrix a)

static ?

a const?

Global qucs::detLaplace (matrix a)

#ifdef 0

static ?

Global qucs::diagonal (qucs::vector diag)

diag is const

Global qucs::eye (int rs, int cs)

Avoid res.get*

Use memset

rs, cs are const

Global qucs::eye (int s)

Do not by lazy and implement it

s is const

Global qucs::fix (const nr_complex_t z)

why not using real fix

Global qucs::fix (const nr_double_t d)

Why not inline?

Global qucs::htos (matrix h, nr_complex_t z1, nr_complex_t z2)

Why not h,z1,z2 const

Global qucs::imag (matrix a)

add imag in place

a is const

Global qucs::inverse (matrix a)

a is const

Global qucs::inverseGaussJordan (matrix a)

a const?

static?

Note: assert non singulat matix

Parameters

[in] a matrix to invert

Global qucs::inverseLaplace (matrix a)

Static?

#ifdef 0

a const?

Global qucs::limexp (const nr_complex_t z)

Change limexp(real) limexp(complex) file order

Global qucs::limexp (const nr_double_t r)

Change limexp(real) limexp(complex) file order

Document M_LIMEXP

Global qucs::matrix::exchangeCols (int, int)

c1 and c2 const

Global qucs::matrix::exchangeRows (int, int)

r1 and r2 const

Global qucs::matrix::get (int, int)

Why not inline and synonymous of ()

c and r const

Global qucs::matrix::matrix (int)

Why not s const?

Global qucs::matrix::operator() (int r, int c) const

: Why not inline

: Why not r and c not const

: Create a debug version checking out of bound (using directly assert)

Global qucs::matrix::operator() (int r, int c)

: Why not inline

: Why r and c not const

: Create a debug version checking out of bound (using directly assert)

Global qucs::matrix::operator+= (matrix)

a is const

Global qucs::matrix::set (int, int, nr_complex_t)

Why not inline and synonymous of ()

r c and z const

Global qucs::operator!= (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Note: Like inequality of double this test is meaningless in finite precision Use instead fabs(x-x0) > tol

Global qucs::operator% (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Global qucs::operator% (const nr_complex_t z1, const nr_double_t r2)

Why not inline

Global qucs::operator% (const nr_double_t r1, const nr_complex_t z2)

Why not inline

Global qucs::operator* (matrix a, nr_complex_t z)

Why not a and z const

Global qucs::operator* (nr_complex_t z, matrix a)

Why not a and z const

Why not inline

Global qucs::operator* (matrix a, nr_double_t d)

Why not d and a const

Global qucs::operator* (nr_double_t d, matrix a)

Why not inline?

Why not d and a const

Global qucs::operator* (matrix a, matrix b)

a and b are const

Global qucs::operator+ (matrix a, matrix b)

a and b are const

Global qucs::operator+ (matrix a, nr_complex_t z)

Move near other +

a and z are const

Global qucs::operator+ (nr_complex_t z, matrix a)

Move near other +

a and z are const

Why not inline

Global qucs::operator+ (matrix a, nr_double_t d)

Move near other +

a and d are const

Global qucs::operator+ (nr_double_t d, matrix a)

Move near other +

a and d are const

Why not inline

Global qucs::operator- (matrix a, matrix b)

a and b are const

Global qucs::operator- (nr_complex_t z, matrix a)

Move near other +

a and z are const

Why not inline

Global qucs::operator- (matrix a, nr_double_t d)

Move near other +

a and z are const

Why not inline

Global qucs::operator- (nr_double_t d, matrix a)

Move near other +

a and z are const

Why not inline

Global qucs::operator- (matrix a, nr_complex_t z)

Move near other +

a and z are const

Why not inline

Global qucs::operator/ (matrix a, nr_complex_t z)

Why not a and z const

Global qucs::operator/ (matrix a, nr_double_t d)

Why not a and d const

Global qucs::operator< (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Global qucs::operator<= (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Global qucs::operator== (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Note: Like equality of double this test is meaningless in finite precision Use instead fabs(x-x0) < tol

Global qucs::operator> (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Global qucs::operator>= (const nr_complex_t z1, const nr_complex_t z2)

Why not inline

Global qucs::real (matrix a)

add real in place

a is const

Global qucs::sign (const nr_complex_t z)

Better implementation z/abs(z) is not really stable

Global qucs::sign (const nr_double_t d)

Move near complex sign

Global qucs::signum (const nr_complex_t z)

Better implementation z/abs(z) is not really stable

Global qucs::signum (const nr_double_t d)

Move near complex signum

Global qucs::sinc (const nr_double_t d)

Why not inline

Global qucs::step (const nr_double_t d)

Create Heaviside alias

Global qucs::step (const nr_complex_t z)

Create Heaviside alias

Why not using real heaviside

Global qucs::stoa (matrix s, nr_complex_t z1, nr_complex_t z2)

Why not s,z1,z2 const

Global qucs::stoh (matrix s, nr_complex_t z1, nr_complex_t z2)

Why not s,z1,z2 const

Global qucs::stos (matrix s, qucs::vector zref, nr_complex_t z0)

Why not inline

Returns: Renormalized scattering matrix

s, zref and z0 const

Global qucs::stos (matrix s, nr_double_t zref, nr_double_t z0)

Why not inline

Returns: Renormalized scattering matrix

s, zref and z0 const

Global qucs::stos (matrix s, qucs::vector zref, qucs::vector z0)

Correct documentation about standing waves [1-4]

Implement Speciale implementation [2-3] if applicable

Returns: Renormalized scattering matrix

s, zref and z0 const

Global qucs::stos (matrix s, nr_complex_t zref, nr_complex_t z0)

Why not inline

Returns: Renormalized scattering matrix

s, zref and z0 const

Global qucs::stos (matrix s, nr_complex_t zref, qucs::vector z0)

Why not inline

s, zref and z0 const

Returns: Renormalized scattering matrix

Global qucs::stoy (matrix s, qucs::vector z0)

s and z0 const

Returns: Admittance matrix

Global qucs::stoy (matrix s, nr_complex_t z0)

Why not inline

s and z0 const

Global qucs::stoz (matrix s, nr_complex_t z0)

Why not inline?

s and z0 const?

Global qucs::stoz (matrix s, qucs::vector z0)

s, z0 const

Returns: Impedance matrix

Global qucs::transpose (matrix a)

add transpose in place

a is const

Global qucs::twoport (matrix m, char in, char out)

m, in, out const

Global qucs::ytos (matrix y, nr_complex_t z0)

Why not inline

y and z0 const

Global qucs::ytos (matrix y, qucs::vector z0)

why not y and z0 const

Returns: Scattering matrix

Global qucs::ytoz (matrix y)

Why not inline

y const

move near ztoy()

Global qucs::ztos (matrix z, qucs::vector z0)

z and z0 const?

Global qucs::ztos (matrix z, nr_complex_t z0)

Why not inline

z and z0 const

Global qucs::ztoy (matrix z)

Why not inline

z const

Global rad (x)

Better as static inline

Rename as deg2rad

Class rectline

Implement evanecent mode

Global skindepth (const nr_double_t f, const nr_double_t rho, const nr_double_t mur)

Factorize the compution of skin depth in a header file.