Hi to everybody I am trying to plot some bode plots, but want to use the LogLinearPlot command (the BodePlot is yet too obscure to me, sorry). My impedance matrices are rather complex in the sense that they are based on 7x7 matrices and that it uses complex numbers. Once I get the impedance expressions and its corresponding admittance I define some (transfer) functions. But it takes age to plot them. And to plot the ARG of the function is even worse. I have added dots after all the numbers to force the use of floating point numbers and I have the feeling that Mathematica makes too many recursions to plot the functions. I have added a limit to PlotPoints and MaxRecursion, but without too much success. I have also tried to find the roots of the admittance function using NDSolve, but this take seven longer (not shown in the attached notebook). I cannot believe that this is the normal speed of Mathematica, I am sure that I am doing something wrong. I am new and will be probably doing a lot of mistakes. Can somebody give me some useful hints? Thank you very much. Stefan P.D. I have attached the notebook. Attachments:

This requires some elaborated work. The basic idea is to make all function "algebraically-ready" before they are inserted into the plot function. Here is an example: f[x] = Det[Inverse[{{1,2},{3,x}}]] g[x] := Det[Inverse[{{1,2},{3,x}}]] Plot[f[x],{x,100,200}] Plot[g[x],{x,100,200}] The first plot should be significantly faster than the second because `f` has the `rhs` evaluated already during definition while the `g` looks for the inversion first and compute the determination. Check the downvalues of `f` and `g` respectively: Use this idea to precompute functions. For example, `Yiidealtotal` is thus converted to a rational function before it is inserted into the plot funciton: Some notes about the optimization: Numeric computation may yield imaginary residues in coefficients, which are difficult for simplification. You want to take a look `Simplify[Chop[#]]&` function to knock down the complicated expressions. To simplify a list of function, you can choose the parallel function to accelerate. For `Yi[x]`: Yi[s_] = ParallelMap[Simplify[Chop[#]] &, nciM.Inverse[ZLRC[s]].nci]; Use the attached notebook to take a look at the details. PS I use high precision numbers throughout the notebook to handle the large coefficients. Attachments:

A count of the number of constants, operators and variables in just one of the items you want to plot In[40]:= LeafCount[20 Log10[Abs[ Yiideal[2. Pi I f]]]] Out[40]= 547063 I tried an assortment of simple things, like replacing 0.+0.I by 0, etc. and, while that removed a few tens of thousands of redundant terms, nothing made a significant dent in the half million items needed to be evaluated hundreds or likely thousands of times to make each plot. When the function to plot is expensive I have sometimes been able to significantly speed things up by constructing a Table of equally spaced evaluations (Log spaced in this case) and then do a ListPlot with Joined->True to reduce the number of evaluations by sometimes an order of magnitude with modest reduction in the publication quality of the graph. Unfortunately with the appearance of your plots I don't think this will likely be acceptable.

`Yiideal` definitely takes huge amount time because it tries to inverse a matrix thousands of time across the plot domain. Yiideal[s_] := nciM.Inverse[ZLRCideal[s]].nci With improved code you can nailed the same plot in 0.08 sec:

LogLinearPlot for Bode too slow