calculus and analysis – An alternative command to compute a logarithmic integral

I am trying to see if Mathematica can calculate:
$$int_0^1frac{ln(x)ln(1-x)ln(1+x)}{x}dx,$$
which has a well-known closed form. So I tried
Integrate(Log(x)Log(1-x)Log(1+x)/x,{x,0,1}) but I waited for about 20 mins and it didn’t show any result, so I stopped the calculations. Is there a command that helps Mathematica calculate the meant integral within few mins?

sequences and series – uniform convergence of a function defined as an integral

I have to prove that this function :
$$f_n(x) = int_0^n e^{-left(1+x^2right)t^2}dt$$ converges uniformly.

In the solution of this exercise, they use a sequence $a_n = int_{n-1}^n e^{-t^2}dt $ and they prove that $|f_n(x)-f_{n-1}(x)|<a_n $. Then they use that to conclude on the convergence of $f_n$.

I don’t really understand the reasoning and why it works.
Could you please help me ?

Thanks !

math – What is the viability of engineering an integral type with values ranging from -1 to 254? Do types like this even exist?

I think what you are asking are valid questions – a little bit broad, but these questions are hard to separate from each other.

1: Does an integral type like this already exist somewhere?
Has it been implemented?

I have never heard of a programming language (or a standard lib in a major programming language) which provides this as a standard number type – and I assume that is what you were asking about here. However, most certainly some programmer somewhere on the world over last decades in one of the gazillions of programs which were written had the requirement to pack values of that range into a single byte.

Hence actually I am convinced the chances are very high that someone in programming history must have created such a type. But get me right – the chances are also high other ranges like (-2 ... 253) or (-42 ... 213) in a single byte have been required and implemented somewhere by someone. But having a special, general datatype in a language or library for each possible range does not really look sensible to me.

2: What are its advantages?

The one and only “advantage” is that is you get a type for exactly that range from -1 to 254 which requires not more than a single byte. No more, no less. One gets a “wrap around” for overflowing exactly from 254 to -1. And since you asked – I fail to see any advantage for bitwise operations – bitwise operations do usually not interact with the number range into which a byte is mapped.

3: What are its disadvantages?

The main disadvantage I see is that standard CPU hardware does not support it directly, and I would not expect this to happen in the near future – the real-world use cases for this very special type are most probably too few to justfify the effort of implementing it in hardware.

4: Is it simply too complex or difficult or inefficient to implement, and is that fundamentally why it does not exist as a common type?

Not every special kind of numbertype, even when it would be simple and efficient to implement, finds its way into a standard lib, a programming language, or (even less likely) into the CPU hardware. For this, the benefits over using an existing type, or over implementing a custom type, must clearly be apparent, and the new number type’s real-world use cases must occur with a certain frequency.

To make the suggested type necessary, the following combination of four requirements must all come together:

  • one needs a type for values in a range from (-1,x)

  • there must exist a real reason why using a type with more than one byte is not acceptable

  • x must be bigger than 127 (otherwise a signed byte type would be sufficient)

  • converting from a byte representation into a type with a larger range, when the potentially signed values are required, and vice versa, when the byte is required again, must be too cumbersome

I would not expect this combination of requirements to occur in the real world very frequently.

So in short, I think that is what is probably missing here: enough real world applications which could so much benefit from this enough to justify the effort for providing this very specialized type as part of some standard library or language.

Using an integral to solve a recursion

  1. This is about the Akrabazzi method, will work if the number of $a cdot f(n/b)$ is not finite? Meaning that we have a sum that depends on our input $n$ ?

What about this:

$$ f(n) = sum_{l=1}^{n} f(n/3^l) $$

Can I say that we need to find the $p$ so that

$$ sum_{j=1}^{n} (frac{1}{3^j})^p =1$$

And because $n rightarrow infty$ we can say it is an infinite geometric sum? Or because $n$ is our input we cant say that… And the akrabazzi fails to deal with this kind of stuff? There is no internet site I found that says $k$ (which in wikipedia is the number of $f(n/b)$ we have needs to be finite.

  1. Moreover, can I use the fact that:
    $$Theta( f(n)+g(n)) = Theta( max{ f(n) + g(n)})$$ to be only for $f(n)$‘s?

Meaning that if we have $$f(n)=f(n-1) + f(n-2) + f(n-3) + dots$$

$$Theta(f(n)) = Theta(f(n-1)) + Theta(f(n-2)) + dots $$

Or this is invalid as it is a sum of $f$ and not some other function $g$

Thank you!

numerical integration – Help with NIntegrate settings to evaluate integral

I am trying to evaluate this integral:
begin{align*}
alpha_{2}=int_{-infty}^{1.645}left(1-Phileft(frac{sqrt{25}}{sqrt{15}} 1.645-frac{sqrt{10}}{sqrt{15}} z_{1}right)right) phileft(z_{1}right) d z_{1}
end{align*}

where $Phi$ is the Normal CDF and $phi$ is the normal PDF. I know that the answer should be 0.03325.

I used the following code, but it doesn’t converge to an answer. Any suggestions?

pdf(x_) := PDF(NormalDistribution(0, 1), x)

cdf(x_) := CDF(NormalDistribution(0, 1), x)

NIntegrate( 1 - cdf(Sqrt(25)/Sqrt(15) 1.645 - Sqrt(10)/Sqrt(15) x)* pdf(x), {x, -Infinity, 1.645})

which returns

NIntegrate::slwcon: Numerical integration converging too slowly; suspect one of the following: singularity, value of the integration is 0, highly oscillatory integrand, or WorkingPrecision too small.

NIntegrate::ncvb: NIntegrate failed to converge to prescribed accuracy after 9 recursive bisections in x near {x} = {-8.16907*10^224}. NIntegrate obtained 8.582639123060543`15.954589770191005*^27949 and 8.582639123060543`15.954589770191005*^27949 for the integral and error estimates.
```