Solution of class design issue of generic of restricted type
As has been said in the comments, it's unclear why you feel you need this behaviour to restrict the types used.  There's an interesting discussion around constraining types here, which includes a link to example code.
So, there's a couple of questions.  Why do you need to restrict it to double / integer types?  Is it really that you want to do is restrict it to types that support certain operations?  What is the actual downside to using it for Decimal / float?
You've presented an example of IDataType, however suggested that really your goal is to put these items into a set.  So this begs the question, are you planning on creating DescriptiveStatisticalSet&lt;IntegerDataType&gt; or DescriptiveStatisticalSet&lt;IDataType&gt;?  If it's IntegerDataType, what are you gaining over Int32 for example?  If it's IDataType, then are you expecting to have both IntegerDataType  and DoubleDataType both present in the same set?  If so, what are you planning on doing if an Integer has the same value as a Double?  Do you keep both because they are different types, or keep whichever one was there first, or keep the Double because it's more flexible, or the Integer because it's faster?
Looking at your actual code, there's some aspects which are worth mentioning.

object Add(object other);


If we look at IntegerDataType, this method takes in an other of type IntegerDataType, but returns an int.  This it not at all obvious from the method signature.  You are working around this to an extent in your DataType class, which does some recasting by creating a new instance of the returned object, however this seems unnecessarily complex.  Particularly since the implementation of Add relies on casting other to the correct type.  Calling Add with a DoubleDataType for example throws a cast exception.

public int Data { get; set; }


Both your Integer and Double data types declare a Data property that has both public getter and setter.  Since you're implementing an interface to setVal, does it really make sense to declare this public setter?  It feels like it would be better for the set to be private, in order to encourage the client to use the interface method, in case you decide you need to do additional checking in the future.
Your DataType class seems to exist purely to create a new item from the object version of Add.  This seems to add unnecessary complexity over just having the initial Add return the correct datatype.  So, it's a bit unclear to me what advantage your current approach has over simply doing this:
public interface IOtherDataType&lt;T&gt;
{
    T Data { get;}

    IOtherDataType&lt;T&gt; Add(IOtherDataType&lt;T&gt; other);
    void SetVal(T other);
}

public class IntType : IOtherDataType&lt;int&gt;
{
    public IntType(int data)
    {
        Data = data;
    }

    public int Data { get; private set; }

    public IOtherDataType&lt;int&gt; Add(IOtherDataType&lt;int&gt; other)
    {
        return new IntType(Data + other.Data);
    }

    public void SetVal(int other)
    {
        Data = other;
    }
}

Which can be used in a similar way...
IntType five = new IntType(5);
IOtherDataType&lt;int&gt; eleven = five.Add(new IntType(6));