Right. Thanks.

I got it right out of the notebook you posted.

Please stop taking this thread in circles.

The integrand code that you gave

{int, {evals}} = Reap[NIntegrate[ 0.00159155/(x^2 + 0.0000001 x + 0.000025^2), {x, -10, 10}, Method -> {"TrapezoidalRule", "Points" -> 100, "RombergQuadrature" -> False}, EvaluationMonitor :> Sow[{x, 0.00159155/(x^2 + 0.0000001 x + 0.000025^2)}, "EVAL"], MaxRecursion -> 0] // Quiet, {"EVAL"}];

has the function 0.00159155/(x^2 + 0.0000001 x + 0.000025^2) but i originally gave the function 0.00159155/(x^2+ 0.000025^2). Can you explain why you added 0.0000001 x ?

(1) It's not divergent. An approximation to a delta function cannot be divergent.

(2) You already have a way to do that area summation. It was in the original post, using NIntegrate.

(3) Your approximate delta function is actually off by a constant factor of around 200 (I assume you knew this but belaboring the detail regardless). The actual unmodified approximation would be alpha/Pi*1/(x^2+alpha^2). It is easy to see how this is related to the variant used in these posts.

alf = 0.000025;
numerator = 0.00159155;
multiplier = numerator/(alf/Pi)

(* Out[79]= 200.000071513 *)

So yours is larger by a factor quite close to 200. Easy to check that this is what is seem in the summation. Recall that integrating a good approximation to a delta function across the origin should give something very close to unity. So we expect your integral to be very close to 200.

NIntegrate[(numerator/(x^2 + alf^2)), {x, -10, 10}]

(* Out[80]= 199.999753203 *)

This can be done as an exact integral by the way.

exact = 
 Integrate[(1/(x^2 + alf1^2)), {x, -10, 10}, Assumptions -> alf1 > 0]

(* Out[85]= (2 ArcTan[10/alf1])/alf1 *)

Now evaluate numerically with substituted value for alf1 and the constant factor restored.

numerator*exact /. alf1 -> alf

(* Out[87]= 199.999753203 *)

(It's really an approximation to the delta "function"). The plot shows a function that is small away from zero, and rises sharply at zero. If you use the option ListPlot[Sort[evals[[1]]], PlotRange->All] then you get a different scale to account for the peak as well as valley, and it looks like a straight line at zero. Squint hard and you see a lone dot at the origin, where it spikes.

All of which is in line with what one might expect for a plot of a function that numerically behaves as an approximation to the delta functional (to call it by the technically correct term).

Which means the integrand will be close to zero away from the origin and will have a spike near the origin.

Your code:

{int, {evals}} = 
  Reap[NIntegrate[
     0.00159155/(x^2 + 0.0000001 x + 0.000025^2), {x, -10, 10}, 
     Method -> {"TrapezoidalRule", "Points" -> 100, 
       "RombergQuadrature" -> False}, 
     EvaluationMonitor :> 
      Sow[{x, 0.00159155/(x^2 + 0.0000001 x + 0.000025^2)}, "EVAL"], 
     MaxRecursion -> 0] // Quiet, {"EVAL"}];

Plot it:

ListPlot[Sort[evals[[1]]]]

You will see something along the lines described above.

The integral from -10 to T, where T ranges to +10, will look approximately like the Heaviside theta function (and I showed that in a prior response).

It would be good to figure out what it is you actually want, and then to state a clear question. As it is, responses are dealing with what seems to be a shifting landscape. Which may explain why a related question on Stack Exchange (which should have had cross-links) was closed.

Sorry if i am being very unclear. Will the plotting graph for integral value and integrand be the same or different? Can you show me one for the integrand?

Thank you for your suggestion! Trying to work out if it is the INTEGRAND values that was plotted.

@Mujtaba Mozumder please do not duplicate discussions, this is against the rules: http://wolfr.am/READ-1ST

Your first thread is deleted and this one is kept. Please keep the same discussions contained in a single thread in future.

If I understand correctly, you can get a Riemann approximation to what you want just by taking partial sums with Accumulate.

ListPlot[Transpose[{evals[[1, All, 1]], Accumulate[evals[[1, All, 2]]]}]]

This is not so accurate though. Perhaps better, if somewhat cumbersome, is to gather the sampling points as you already do, order them, then redo the integrations between consecutuve pairs thereof. Accumulating these subinterval integrals will give the picture I think you are after. Here is the idea.

(* repeat code from original post *)
rulePoints = 5;
sampledPoints = 
  Reap[NIntegrate[(0.00159155/(x^2 + 0.000025^2)), {x, -10, 10}, 
     Method -> {"LocalAdaptive", "SymbolicProcessing" -> 0, 
       Method -> {"TrapezoidalRule", "Points" -> rulePoints}, 
       "SingularityHandler" -> None}, EvaluationMonitor :> Sow[x]]][[2, 1]];

(* Now integrate between sampled points *)
newpoints = Sort[sampledPoints];
ivals = Table[NIntegrate[(0.00159155/(x^2 + 0.000025^2)), {x, newpoints[[i]], 
     newpoints[[i + 1]]}], {i, Length[newpoints] - 1}];

Plot:

ListPlot[Transpose[{Rest[newpoints], Accumulate[ivals]}], PlotRange -> All]

Maybe slightly better on the eyes:

ListPlot[Accumulate[ivals], PlotRange -> All]