Greetings to my blog readers!
In this post I will share with you a trick of achieving something that, quite frankly, I do not recommend doing – dynamically casting types in generic collections.
In my previous post here I showed you that generic custom collections are great, type-safe and can be easily created by deriving from System.Collections.ObjectModel.Collection which provides a wealth of ready-made functionality. So, suppose you have a need for a custom generic collection like this, but you need to be able to treat it as a polymorphic type. For example, if you create a collection of integers, you want to be able to convert it to a collection of doubles when there is a need to do so. Or the other way around.
To begin with, you may try doing something like this, where NumericalList class is initialised with an int type, but then attempting to cast to a list of doubles to save into doubleList:
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
namespace TypeSafety
{
sealed class NumericalList<T> : System.Collections.ObjectModel.Collection<T>
{
}
class EntryPoint
{
static void Main(string[] args)
{
NumericalList<int> intList = new NumericalList<int> {1,2,3,4,5};
var doubleList = from double n in intList select n;
foreach (var d in doubleList)
Console.WriteLine(d);
Console.ReadLine();
}
}
}
The above code will compile, but it will not run. The reason for this is not very intuitive because one should be able to cast an int to a double implicitly. The runtime exception is System.InvalidCastException, originating from the line where doubleList is initialised and later unwound in the foreach block. So, what is going on here?
Examining the IL for the above code we can find this statement corresponding to the instructions where we attempt the implicit cast: System.Linq.Enumerable::Cast(class[mscorlib]System.Collection.IEnumerable)
The Enumerable.Cast is called by the foreach iterator, and the cast fails with the exception. The method Cast is an extension to Enumerable class. You can examine the source code for the whole class here. Below I am providing the snippets of code from the referencesource.microsoft.com that are relevant to our problem:
public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source) {
IEnumerable<TResult> typedSource = source as IEnumerable<TResult>;
if (typedSource != null) return typedSource;
if (source == null) throw Error.ArgumentNull("source");
return CastIterator<TResult>(source);
}
static IEnumerable<TResult> CastIterator<TResult>(IEnumerable source) {
foreach (object obj in source) yield return (TResult)obj;
}
Since as never throws an exception, the exception is thrown from the CastIterator extension where the cast takes place. The explicit cast is from object to, in our case, double, which is invalid.
Ok, now that we know where and why the code fails, let’s look at how we can fix it. A simple fix is to move the cast to where it will work, i.e. to where the selected list element (an integer) can be cast to a double one at a time:
var doubleList = from n in intList select (double)n;
This does the job. But not at a class level. To be able to perform the kind of conversion we tried originally, we need to modify the default Cast extension. In particular, we need to remove the ‘casting object to a double’ part. To do this, we can utilise the dynamic keyword, which allows us to determine the type at runtime. I am not going to go into the details about this keyword here. Take a look at this comprehensive article on MSDN magazine if you are interested to learn more about dynamic. Below is the modified solution adapted for integers and doubles:
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
namespace TypeSafety
{
sealed class NumericalList<T> : System.Collections.ObjectModel.Collection<T>
{
public IEnumerable<TRes>CustomCast<TRes>()
{
if (typeof(TRes).Equals(typeof(double)) || typeof(TRes).Equals(typeof(int)))
{
dynamic runtime;
foreach (var tr in this)
{
runtime = tr;
yield return (TRes)runtime;
}
}
}
}
class EntryPoint
{
static void Main(string[] args)
{
NumericalList<int> intList = new NumericalList<int> {1,2,3,4,5 };
var doubleList = from double n in intList.CustomCast<double>() select n;
foreach (var d in doubleList)
Console.WriteLine(d);
Console.ReadLine();
}
}
}
The above works for doubles and integers.
![X=F^{-1} (U),U\approx Unif[0,1]](https://s0.wp.com/latex.php?latex=X%3DF%5E%7B-1%7D+%28U%29%2CU%5Capprox+Unif%5B0%2C1%5D&bg=ffffff&fg=111111&s=0&c=20201002)
is the inverse of the cumulative distribution function (i.e. any given c.d.f.), and X is the desired random variable satisfying 
property. Again, the c.d.f. can be for any required distribution for which the inverse is well-defined.
. Figure 1 shows the probability on the y-axis and the random variable on the x-axis. The probability axis corresponds to the uniform random variable range, which is [0,1]. Thus, we can use the y-axis to map to the x-axis, which would give us a random variable in (-3,3) interval. This random variable is normally distributed with mean 0 and standard deviation of 1. In Figure 1 I have marked the middle of both axis to make it clear that uniform random variables between 0 and 0.5 would map to normal random variables that are negative. The uniforms above 0.5 map to positive r.vs.
and 
are constants (see the code for their values). The above is defined for 
. For 
, we can utilize Chebyshev’s approximation, as demonstrated in [1]:
over the [-7,7] range for x.
, such that 
follows exponential distribution with mean 2 and 
(i.e. bivariate normal).
, which says that for some small change h, we can approximate the rate of change in y to the rate of change in x using this difference ratio. This can be rearranged to give us 
. Thus: ![y(x+h)=h[\frac{dy}{dx}]+y(x)](https://s0.wp.com/latex.php?latex=y%28x%2Bh%29%3Dh%5B%5Cfrac%7Bdy%7D%7Bdx%7D%5D%2By%28x%29&bg=ffffff&fg=111111&s=0&c=20201002)
. This expression can be used to solve a differential equation for some other value of x, since we can start with our initial condition, take a small step h, and iteratively approximate y(x). The smaller is the increment step, the better will be our approximation. This is the fundamental idea behind the Euler’s method.![y(x+h)=y(x)+h[\frac{1}{6}(k1+2\times k2+2\times k3+k4)]](https://s0.wp.com/latex.php?latex=y%28x%2Bh%29%3Dy%28x%29%2Bh%5B%5Cfrac%7B1%7D%7B6%7D%28k1%2B2%5Ctimes+k2%2B2%5Ctimes+k3%2Bk4%29%5D&bg=ffffff&fg=111111&s=0&c=20201002)
where
, 
, 
and 
.
equal to zero. There are many approaches to findings the roots of equation in nonlinear algebra. Some of the well-known ones include: the linear interpolation (or bisection) method, Newton’s method, Bernoulli’s method and its variations. In this post I am demonstrating an implementation of the two basic methods: bisection and Newton’s. We will also compare their performances.
, where 
is the current approximation. This process terminates when either of the following conditions is reached: (a) we find the solution to some acceptable accuracy, or (b) we do not find the solution and terminate because the current distance on which we iterate is less than some error value (i.e. we have exhausted the interval without convergence), or we have exceeded the number of allowed iterations. The solution may not be obtained if the starting points are chosen poorly, and there are no roots on the [a,b] interval. For example, take a look at Figure 1, which is a plot of 
, where some possible [a,b] interval is marked. Imagine instead we pick [a,b] to be [2,3]. Since nowhere on [2,3] is 
, this interval does not provide any roots.
, we can improve upon the guess by updating it with the value of x for which 
is the tangent line function.
. This is why I think it is a bit more complex. Also, there are several conditions, under which this method fails to find a solution. One of them is that 
is undefined. Another is that 
. More conditions can be found on Wikipedia.
. In my implementation, the bisection method finds the negative root, while the Newton’s method finds the positive root, since the initial guess is closer to the positive root. It takes 13 iterations to approximate the solution with the bisection method. While it takes only 4 iterations with the Newton’s method.
codefying 