Books in black and white
 Books Biology Business Chemistry Computers Culture Economics Fiction Games Guide History Management Mathematical Medicine Mental Fitnes Physics Psychology Scince Sport Technics

# Theory of Linear and nonlinear circuits - Engberg J.

Engberg J. Theory of Linear and nonlinear circuits - Wiley & sons , 1995. - 154 p.
ISBN 0-47-94825
Previous << 1 .. 75 76 77 78 79 80 < 81 > 82 83 84 .. 85 >> Next

for nl from 0 to sm do
for n2 from 0 to sm-nl do sn : = nl+r.2: if (sn >= 2) then
for no from T.sm[sn-l]+l to T,src[sn] do
V := permute(op(4, Mlto.smfrio] )): for np to numbperm(sn, sn) do vl := [op(l..nl, op(np,V))]: v2 := [op(nl+l..sn, op(np,V))]: if (sort(vl) = vl) ^d (sort(v2) = v2) then pt := pt+1:
M2m.sm[pt] := [[sn], [nl,n2], [nl!*n2!], [op(op(np, 7))]]
od
od
fi
od od:
. sm LQj • ~ pt:
od:
### Nlistgen ###*#########£###############################*################
# Determine Nlistgen lists for order to MAXORDER do no := 0:
E.l. Program listing for listgen source code
279
Lambda := [seq(2~(o-l), o=l..order)]:
# case 1
for ptl to order do no := no+1:
N.orderCno] := [[1, op(ptl, Lambda)], [op(ptl, Lambda)]] od:
# case 2
V := chooso(Lambda,2):
lor ptl to mmbcomb(order, 2) do
Number := convert(op(ptl, V), f+‘): no := no+1:
N. order[no] [[2, Number], [op(op(ptl, V))]] od:
# case>=3
lor ord from 3 to order do
V := choose(Lambda, ord): for ptl to mxmbcombCorder, ord) do vl := op(ptl, V): v2 := choose(vl, l):
Number := convert(vl, f + ‘): for pt2 from 2 to ord-1 do
v2 := [op(v2) , op(choose(vl, pt2))j od:
R := [convert(op(l, v2), '+')]: for pt2 from 2 to nops(v2) do
R := [op(R), convert(op(pt2, v2), '+')] od:
R := sort(R): no := no+1:
N.orderLno] := [[ord, Number], [op(R)]j
od
od
od:
### SAVE RESULTS IN FILE
¥ Save 0. M. and N lists in file 'lists.mf 1 print (' Saving o- , m- , ала n-liaua i:s. Г lie: liatd.m'); save i21L, Mlm. (2 . .MAXORDER) , M2m. (2 . . MAXCRDEP.) ,
N (i . MAXORDER.) ; lists . r?.' : lprint(fList generation completed') end: # listgen
280 E. Determination of Volterra transfer functions using Maple
E.2 Program listing for vtf source code
# vtf - determination of a given Volterra transfer function
# vtf(mL, psiL, MAXORDER, sysdefL, caltype)
#
# mL: List of orders specified as [ml,...,mK]
# psiL: List of psi frequencies specified as
# [psi{l,1},...,psi{l,ml>(........,psi{K,1},...psi{K,mK>]
# MAXORDER: The maximum order for which the system of analysis is used
# sysdefL: A system definition list specified as [K, Q, R, jL]
# caltype: Calculation type specified as either one of: (l) falgff for
t full algebraic evaluation, (2) <algr< for recursive
# algebraic evaluation, and (3) 'nura' for numerical evaluation ########################################################################### volfun[vtf] :- proc(mL, psiL, MAXORDER, sysdefL, caltype)
local cfak, con, ImdFrqL, i, k, MmL, MptL, UL, NoCgVar, NptL, no, ord, order, portL, p, psi, psiGL, a, r, resp, result, Sm, sm, uresult* usubresult: global K, Q, R, jL, AI J В, a, Ъ, u, bk:
### TEST FOR VALID INPUT DATA a########*####3##*########################*S# if (nargs = 5) then if not type([args],
[list(nonnegint), list, posint, [posint, posint, posint, list], name]) then
ERR0R('Invalid arguments')
fi:
if (convert(mL, * + ') <> nops(psiL)) or (nops(mL) <> sysdefLil]) then ERR0R('Unbalanced number of elements in argument lists') f i:
if (nops (sysdefL) <> 4) or (nops(sysdefL[4]) <> sysdefL[2]) then ERR0R('Invalid sysdefL')
fi
else
ERR0R('Invalid number of arguments') ii:
##\$ INITIALIZE
if not tvoeCHim.MAXORDER[0] . posint-) then read ‘lists m1:
if not type(Mlm.MAX0RDER[0], posint) and (MAXORDER <> 1) then
ERR0R('Execute vsa[listgen](MAXORDER) with MAXORDER = ' , MAXORDER) fi:
Е.2. Program listing for vtf source code
281
# Load the necessary procedures from the linalg package with(linalg, dotprod, multiply, scalarmul, subvector):
# Unassign global variables
unassign(’K’, ’ R', ' jL'):
Iprint('Initialization completed')
fi:
# Define global variables
if (K <> sysdefL[l]) or (Q <> sysdefL[2]) or (R <> sysdefL[3]) or (jL <> sysdefL[4]) then К := sysdefL[1]:
Q := sysdefL[2]:
R := sysdefL[3]: jL : = sysdefL[4] :
# Define vectors and matrices
AI := array(l..R, 1..Q, sparse):
3 := array(i..q, 1..K, sparse): a := array(l..R, sparse): b := array(l..K, sparse): u := array(l..Q, sparse): bk : = array(l..Q, sparse): for resp to 2~MAXQRDER-1 do x.resp := array(l..R):
X.resp := array(l..R) od:
Iprint(‘Global variables updated'): fi:
### CALCULATE
# Calculate the sum sm=ml+...+mK sm := convert(mL, ' + '):
# Calculate the total number of contributions, 3iu Sm := 2'sm - 1:
Determine tne port numDer list, porti-
«-r-i-r ■ - roani'sani'V i=1 qtj.'V ) X =
# Calculate the intermodulation frequency list
ImdFrqL := [seq(dotprod(i21L[k], [op(1..nops(i21L[k]), psiL)]), k=l..Sm)]
2.3*2
E. Determination of Volterra transfer functions using Maple
# Calculate all first order x vectors for no to sm do
# Determine the input port number, к к op(no, portL):
# Determine where to put the response, x.resp resp := op(2, op(l, N.sm[no])):
# Determine the frequency at which the x.resp vector is to be determined psi := op(resp, ImdFrqL):
# Update the global inverted A matrix, AI Alcal(psi):
# Update the В matrix and set bk equal to minus the k'th column of В Beal(psi) :
Previous << 1 .. 75 76 77 78 79 80 < 81 > 82 83 84 .. 85 >> Next