Qucs-core: Todo List

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::ellipk (nr_double_t)

move to common math

Global main (int argc, char **argv)

replace environement name root by "/" in order to be filesystem compatible

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::EgSchottky

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

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::GMin

Define and document

Global qucs::Hp

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

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?

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 #limitexp

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

Global qucs::operator% (const nr_double_t r1, 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_double_t r2)

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- (matrix a, nr_complex_t z)

Move near other +

a and z are const

Why not inline

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)

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

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_complex_t z)

Create Heaviside alias

Why not using real heaviside

Global qucs::step (const nr_double_t d)

Create Heaviside alias

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, nr_complex_t zref, nr_complex_t z0)

Why not inline

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

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

Why not inline

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

s, zref and z0 const

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

Why not inline

s, zref and z0 const

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

Why not inline

s and z0 const

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

s and z0 const

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

s, z0 const

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

Why not inline?

s and z0 const?

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, qucs::vector z0)

why not y and z0 const

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

Why not inline

y and z0 const

Global qucs::ytoz (matrix y)

Why not inline

y const

move near ztoy()

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

Why not inline

z and z0 const

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

z and z0 const?

Global qucs::ztoy (matrix z)

Why not inline

z const

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.

File tswitch.cpp

add a property to allow choosing the resistance profile (cubic spline, linear, abrupt)