Analog Obsession looking for new owner

[AnalogObsession]

Hello,

I have to transfer whole company or plugins' assest for some serious reasons.

What will you get?

If you buy whole company, i will give you 'everything'! Company name, rights, plugins' assests, GUIs, analog modeling framework, website, database and more... Including 1 year free support for existing plugins to update them to Diamond series with new codes and GUIs.

If you buy only assests, you will get plugin's codes and analog modeling framework. No GUI pieces. And free support for legacy plugins to make them Diamond series plugins.

No single plugin's right on sale. Only for all.

If you have any questions, please contact via only email.

contact(AT)analogobsession(DOT)com

Thanks.

[frizzbee]

is this some kind of attention seeking? didn't you have your big come back not long ago?

[AnalogObsession]

is this some kind of attention seeking? didn't you have your big come back not long ago?

Not attention seeking. Also not good way to take attention...

Company is still fine but for some personal reasons, i have to transfer.

[stratum]

Just curious, what is that "analog modeling framework"?

[AnalogObsession]

Just curious, what is that "analog modeling framework"?

It's converting circuit to C++. More is secret

So new programmer need to know low level circuit design at least... But i will already teach and support.

[stratum]

You should be able to tell a little more as these things are not secret.

A few possibilities
- wave digital filters
- modified nodal analysis
- measurement and dynamic convolution
- just an high level abstraction

In fact not describing the method was one of the things you have been doing wrong.
If you do not have the marketing capability of the big boys, you can describe the modeling method, and write a blog full of equations.
That can establish credibility for your plugins.

[Burillo]

The "framework" he's using is in fact not a secret, if you look hard enough. it's called Faust (source).

[stratum]

OK, now I know why he was having difficulty matching the cpu efficiency of the competition.
It's hard to convert this to an hand written optimized assembly code. It's first necessary to figure out what the hell is going on in the Faust generated code.

Code: Select all

     float fTemp0 = ((((fRec1[0] * ((fRec2[0] * ((2.53244472f * fRec2[0]) + -2.52782989f)) + -2.55191851f)) + (fRec3[0] * (((fRec1[0] * ((fRec2[0] * (2.39224625f - (2.3966136f * fRec2[0]))) + 2.41504288f)) + (fRec2[0] * ((2.97997594f * fRec2[0]) + -3.00986648f))) + -2.542557f))) + (fRec2[0] * (3.17996812f - (3.14868951f * fRec2[0])))) + 2.68679452f);
      fRec0[0] = (*in1 - ((((fRec0[1] * ((((fRec1[0] * ((fRec2[0] * (3.28740835f - (3.29274011f * fRec2[0]))) + 3.31676102f)) + (fRec3[0] * (((fRec1[0] * ((fRec2[0] * ((3.15546703f * fRec2[0]) + -3.15034962f)) + -3.17850184f)) + (fRec2[0] * (3.82386899f - (3.85928059f * fRec2[0])))) + 3.35960817f))) + (fRec2[0] * ((4.02680874f * fRec2[0]) + -3.9897368f))) + -3.50551343f)) + (fRec0[2] * ((((fRec1[0] * ((fRec2[0] * (0.934723735f - (0.937751412f * fRec2[0]))) + 0.947525024f)) + (fRec3[0] * (((fRec1[0] * ((fRec2[0] * ((0.874959588f * fRec2[0]) + -0.872106731f)) + -0.884132981f)) + (fRec2[0] * (1.14007628f - (1.10832298f * fRec2[0])))) + 0.928419292f))) + (fRec2[0] * ((1.18686604f * fRec2[0]) + -1.22009742f))) + -0.994844198f))) + (fRec0[3] * ((((fRec1[0] * ((fRec2[0] * ((1.6980468f * fRec2[0]) + -1.69430232f)) + -1.71236753f)) + (fRec3[0] * (((fRec1[0] * ((fRec2[0] * (1.63021028f - (1.63381302f * fRec2[0]))) + 1.64759207f)) + (fRec2[0] * ((1.98766482f * fRec2[0]) + -1.95411611f))) + -1.74550831f))) + (fRec2[0] * (2.03056645f - (2.06568694f * fRec2[0])))) + 1.81427062f))) / fTemp0));
      float fTemp1 = (1.0f - fRec2[0]);
      float fTemp2 = (fRec2[0] * fTemp1);
      *out1 = ((((((fRec0[0] * ((((fRec1[0] * ((2.07792711f * fTemp2) + 2.08234882f)) + (fRec3[0] * (((fRec1[0] * ((fRec2[0] * (0.0f - (1.96647441f * fTemp1))) + -1.97065902f)) + (fRec2[0] * (2.40981579f - (2.44513631f * fRec2[0])))) + 2.1027143f))) + (fRec2[0] * ((2.58356977f * fRec2[0]) + -2.54655361f))) + -2.22175026f)) + (fRec0[1] * ((((fRec1[0] * ((fRec2[0] * (0.0f - (2.0410006f * fTemp1))) + -2.04461694f)) + (fRec3[0] * (((fRec1[0] * ((1.96380627f * fTemp2) + 1.96729732f)) + (fRec2[0] * ((2.38908958f * fRec2[0]) + -2.41825509f))) + -2.04841661f))) + (fRec2[0] * (2.51309466f - (2.4825294f * fRec2[0])))) + 2.12845993f))) + (fRec0[2] * ((((fRec1[0] * ((fRec2[0] * (0.0f - (2.07951403f * fTemp1))) + -2.08538675f)) + (fRec3[0] * (((fRec1[0] * ((1.96798885f * fTemp2) + 1.97355795f)) + (fRec2[0] * ((2.44698095f * fRec2[0]) + -2.41166043f))) + -2.10574365f))) + (fRec2[0] * (2.54816365f - (2.58517957f * fRec2[0])))) + 2.22460103f))) + (fRec0[3] * ((((fRec1[0] * ((2.04258776f * fTemp2) + 2.04765487f)) + (fRec3[0] * (((fRec1[0] * ((fRec2[0] * (0.0f - (1.96532071f * fTemp1))) + -1.97019613f)) + (fRec2[0] * (2.42013574f - (2.39097047f * fRec2[0])))) + 2.0514822f))) + (fRec2[0] * ((2.48482394f * fRec2[0]) + -2.51538897f))) + -2.13199639f))) / fTemp0));
      fRec1[1] = fRec1[0];
      fRec2[1] = fRec2[0];
      fRec3[1] = fRec3[0];
      for (int j0 = 3; (j0 > 0); j0 = (j0 - 1)) {
        fRec0[j0] = fRec0[(j0 - 1)];

[Burillo]

i don't think competition uses much of "hand written optimized assembly code" as much as you think. the problem isn't lack of hand-written assembly, it's lack of hand-written code (as opposed to generated one)

[ghettosynth]

I'm familiar with Faust, I have done a few prototypes with it, but AFAIK there is no tool that generates Faust code from a circuit model that is publically available, right? So that can only be a part of the story here. FWIW, I'm less interested in the OPs drama than I am in useful open source tools so if I've missed something then I'm all ears.

[mystran]

i don't think competition uses much of "hand written optimized assembly code" as much as you think. the problem isn't lack of hand-written assembly, it's lack of hand-written code (as opposed to generated one)

Yeah, anyone serious about circuit modelling is shooting themselves in the foot with a nuclear warhead if they are trying to write their solvers manually. It's a huge waste of time and you end up with slow code, because several useful optimisations are just far too labor intensive and error-prone to even consider if you have to do it all manually.

[stratum]

I'm familiar with Faust, I have done a few prototypes with it, but AFAIK there is no tool that generates Faust code from a circuit model that is publically available, right? So that can only be a part of the story here.

Apparently Faust has many toys you can play with:

https://ccrma.stanford.edu/~rmichon/pub ... stLibs.pdf
https://github.com/grame-cncm/faustlibraries

Circuit model, eh, depends on what you mean by that.

While this may not match any specific circuit, it may be a good starting point for experimentation and you can probably adjust the overall behavior to make it resemble the analysis results obtained from some known circuit.
https://github.com/grame-cncm/faustlibr ... /tubes.lib

[Obsolete236871]

There is also a tool that (in a future update) promises to be able to turn Spice circuit modelling directly into VST plugins.

http://www.livespice.org/

[stratum]

i don't think competition uses much of "hand written optimized assembly code" as much as you think. the problem isn't lack of hand-written assembly, it's lack of hand-written code (as opposed to generated one)

Yeah, anyone serious about circuit modelling is shooting themselves in the foot with a nuclear warhead if they are trying to write their solvers manually. It's a huge waste of time and you end up with slow code, because several useful optimisations are just far too labor intensive and error-prone to even consider if you have to do it all manually.

So.. dump the traced execution of the code that the solver was executing to a text file (assuming the decisions are fixed) and let the compiler optimizer handle that. I recall you had mentioned something like that.

[mystran]

i don't think competition uses much of "hand written optimized assembly code" as much as you think. the problem isn't lack of hand-written assembly, it's lack of hand-written code (as opposed to generated one)

Yeah, anyone serious about circuit modelling is shooting themselves in the foot with a nuclear warhead if they are trying to write their solvers manually. It's a huge waste of time and you end up with slow code, because several useful optimisations are just far too labor intensive and error-prone to even consider if you have to do it all manually.

So.. dump the traced execution of the code that the solver was executing to a text file (assuming the decisions are fixed) and let the compiler optimizer handle that. I recall you had mentioned something like that.

That will get you started, although you can take it further. For example, you can optimise the order in which you solve the circuit, such that you can pre-compute the solution (but don't do it until you know your sampling rate, so you can treat that as constant too) as far as possible and keep the inner Newton-loops as small as possible (you don't want to iterate the full circuit for those). Stuff like that. It's not rocket-science, but it's stuff that you really don't want to do manually (because the resulting code makes no sense when you look at it) and which benefits from domain specific knowledge (ie. it's unrealistic to expect the compiler to do the right thing without some help).

edit: oh and you probably don't want to build MNA matrices by hand either, since it's pretty to stamp them automatically from a net-list or similar