Is there anyway to avoid using [fexpr~] and make it still function the same?

For Example, I want an abstraction or subpatch that functions the same as

fexpr~ $x2[0]*$x1[0] + $x3[0]*$x1[-1] + $x4[0]*$x1[-2] - $x5[0]*$y1[-1] - $x6[0]*$y1[-2]

Is it even possible?

I'm asking this question because I'm developing an iOS app using pd and I've heard Apple doesn't allow me to use GPL license stuff such as expr~, fexpr~.

Any help please?

All of the stuff in brackets represent sample-wise delays. So $x1[-1] means the first inlet delayed by one sample (or, you can think of it as the previous input sample). These can easily be created using [delread~] and [delwrite~]. Just remember to use order-forcing with subpatches to make sure you aren't being restricted by blocksizes.

$y1[-2] means the output delayed by two samples and being fedback into the equation. These delays can also be done with [delread~] and [delwrite~], but since it's being fed back you have to use [block~ 1] to make sure you get the right samples.

With the right patching, though, you might be able to get away with using [rzero~] and [rpole~] instead of [delread~] and [delwrite~]. If so, then you can also avoid the troubles of using [block~ 1].

Thank you Maelstorm, I've been trying to figure out what you said for the few days but I don't really get it since I'm kinda newbie in audio side of pd.
Would it be so rude if I ask anyone in this forum to make an abstraction for me?
which functions the same as below, but avoid using fexpr~ or vanilla unfriendly objects.
I would at least be glad to hear further advice on how to do this easily.

fexpr~ $x2[0]*$x1[0] + $x3[0]*$x1[-1] + $x4[0]*$x1[-2] - $x5[0]*$y1[-1] - $x6[0]*$y1[-2]

i am reviving this because of the original topic.

when trying to copy an fexpr expression to max/msp - where no signa rate expression obejcts exist - i know what i have to do for the "k-1" thing, and i also know what i have to do when i need to make a loop (lowering the vectorsize to 1 sample is possibly using poly~ subpatches in max)

what i dont understand is why the heck it makes a difference in pd to use either fexpr~ or expr~?

if there would be an expr~ obejct in max, you would not need to have it processing sample by sample in order to make a feedback loop sample by sample, there are enough methods to do that using processing in vectors...

@Obineg

what i dont understand is why the heck it makes a difference in pd to use either fexpr~ or expr~?

if there would be an expr~ obejct in max, you would not need to have it processing sample by sample in order to make a feedback loop sample by sample, there are enough methods to do that using processing in vectors...

In pd there aren't "enough methods to do that using processing in vectors".
You need to use [block~ 1] and then calculate the time for a 1-sample delay in milliseconds in order to use [delwrite~] and [delread~] (or, maybe it's possible with [tabreceive~] and [tabsend~])

at any rate it's much easier to just write y1[-1] in an [fexpr~] than fuss with other objects in order to create 1-sample feedback or even just other 1-sample delays.

@seb-harmonik.ar said:

You need to use [block~ 1] and then calculate the time
for a 1-sample delay in milliseconds

in max it is pretty similar, you would need to make a poly~ subpatcher and set the vectorsize inside it to 1.

then you can make a loop - which requires a vectordelay, which is provided by either send/receive or the tapping buffer.

at any rate it's much easier to just write y1[-1] in an ```[fexpr~]

yes, i think it is great to be able to write that into an object.

however, i feel the need to grasp the difference between fexpr and expr in pd in order to be able to port it to max.

the pd helpfiles for expr and fexpr were not very helpful to understand the difference, or in other words, their coexistence.

@Obineg [fexpr~] is quite a bit less efficient than [expr~]
so, if you don't need per-sample memory or feedback it is much better to use [expr~]
why? because in order to store each of the output samples for the current processed sample, [fexpr~] needs to operate on single passes of the perform loop, then store the input and output samples.
I think since [expr~] deals with a block (vector) of samples it is generally more efficient since it can pipeline and vectorize the actual instructions. And it's not possible to do that if the next output sample is dependent on the current output sample.
plus, due to the way pd uses the input and output samples in a dsp graph, the input and output buffer might be the same buffer. This means that if you want to read an input sample from the past you first have to store it somewhere to make sure it won't be overwritten when writing to the output. so [fexpr~] also has to do that when [expr~] doesn't (since [expr~] only processes input samples as a vector).
basically: [expr~] operates on the whole vector/block (meaning the constituent functions/operators are applied "at once" over the vector/block for every part of the computation), [fexpr~] operates on the individual samples of that vector/block. (meaning the constituent functions/operators are applied in turn to every sample in the block, one at a time, for every part of the computation)

that was the missing part in my brain, thanks.

so it is the combination of a shared input and output buffer (something which does not exist in MSP) and a feedbackloop makes fexpr "possible".

otherwise using expr~ or other signal objects running under a vectorsize of 1 are doing the same.

the fact that pd is so different from max in these regards makes it really difficult to read these fexpr~ patches. (i am good in max and audio DSP - but max is the *only *language i can think in.)

i will try that with an example in the next days and then might come back to you,

so i just looked into it again, and i still dont understand the syntax.

the helpfiles says $x1 and $x2 would be a shorthand for $x1[0] and $x2[0] and the same goes for y.

so far, so good. but what IS y1 when there is only two inlets?

ah, it is the output values^^

so then how can i initialize y1?

@Obineg the set message. see the [fexpr~] help file