# [SciPy-user] sine transform prefactor

Lubos Vrbka lists@vrbka....
Sat Jul 26 11:24:48 CDT 2008

```hi,

> I don't know a whole lot about transforms however, I do remember one bit of
> information that may be useful to you:  The prefactors in the sine transform
> (which is of course related to the fourier transform) are actually matters
> of convention.  The sqrt(2/pi) is not always the prefactor!  The prefactor
> is usually chosen to be sqrt(2/pi) so that the inverse transform will also
> have a prefactor of sqrt(2/pi) and there will be some symmetry in the two
> formulas so that they look alike and are easier to remember.  However,
> SOMETIMES people chose the transform or inverse transform (I can't recall
> which) to have a 2/pi prefactor, and the other to have no prefactor.  I
> comes down to a matter of convention and it doesn't matter which one you
> chose, as long as you are consistent.
well, all this is clear to me.

if i do
iDST(DST(f(r))
on discrete data, i get the original data back (expected result). this
would indicate that
1) either the sqrt(2/pi) norm shouldn't be used for discrete data (why?)
2) the sqrt(2/pi) factor is taken care of somewhere inside the DST
function (how?)

this is the thing i'd really love to know - is the answer 1 or answer 2
correct?

in my opinion, it shouldn't matter what combination of norms i use, as
soon as they are consistent - but at the moment, i have the following
problem. i need to iteratively solve
H(r) = C(r) + C(r)*H(r)
where the star denotes convolution and H and C are functions of
interest. the easiest way to solve this should be fourier transforming
this, solving
H(k) = C(k) + C(k)H(k)
by
H(k) = C(k)/(1-C(k))
and then transforming H(k) back for further processing. in practice, i
calculate C, transorm it into fourier space, solve for H and transform
it back, where it serves as a 'parameter' for new C.

due to the nature of my functions, the 3D-FT can be replaced by 1D
fourier-bessel transformation AND some constants. depending on how one
distributes the normalization of FT, one arrives at, e.g.,
FB(f(r)) = f(k) = 4pi/k int_0^infty f(r) r sin(kr) dr
iFB(f(k)) = f(r) = 1/2rpi^2 int_0^infty f(k) k sin(kr) dk
this can be calculated using fourier-sine transform of a new function
F(r)=f(r)*r and F(k)=f(k)*k, respectively
FB(f(r)) = 4pi/k sqrt(pi/2) int_0^infty F(r) sin(kr) dr
iFB(f(r)) = 1/2rpi^2 sqrt(pi/2) int_0^infty F(k) sin(kr) dk
so one would expect that the story is clear - do fourier-sinus, multiply
with the respective normalization constant... but the problem is, that
this doesn't work.

at this point i asked the question - *should* i actually use these
factors (coming from continuous transforms) also in the case of discrete
transforms, which are self normalized to a number of discretization points?

> PS> Dear Everyone, I am trying to get my email mailing list style fixed so
> that I don't break mailing list etiquette.   Please email  me personal to
> check me if this email sucked.  Sorry for my previous mistakes!
just a comment - don't change the subject line, since it breaks the thread

best,

--
Lubos _@_"
http://www.lubos.vrbka.net
```