In R every &quot;object&quot; has a `mode` and a `class`. The former represents how an object is stored in memory (numeric, character, list and function) while the later represents its abstract type. For example:

    d &lt;- data.frame(V1=c(1,2))
    class(d)
    # [1] &quot;data.frame&quot;
    mode(d)
    # [1] &quot;list&quot;
    typeof(d)
    # list

As you can see data frames are stored in memory as `list` but they are wrapped into `data.frame` objects. The latter allows for usage of member functions as well as overloading functions such as `print` with a custom behavior. 

`typeof`(`storage.mode`) will usually give the same information as `mode` but not always. Case in point:

    typeof(c(1,2))
    # [1] &quot;double&quot;
    mode(c(1,2))
    # [1] &quot;numeric&quot;

The reasoning behind this can be found [here][1]:

&gt;  The R specific function **typeof** returns the type of an R object
&gt;
&gt;  Function **mode** gives information about the mode of an object in the sense of Becker, Chambers &amp; Wilks (1988), and is more compatible with other implementations of the S language

The link that I posted above also contains a list of all native R `basic types` (vectors, lists etc.) and all `compound objects` (factors and data.frames) as well as some examples of how `mode`, `typeof` and `class` are related for each type.



  [1]: http://stat.ethz.ch/R-manual/R-devel/doc/manual/R-lang.html#Objects

`type` really refers to the different data structures available in R.  This discussion in the  [R Language Definition manual](http://cran.r-project.org/doc/manuals/R-lang.html#Objects) may get you started on objects and types.


On the other hand, `class` means something else in R than what you may expect.  From
the [R Language Definition](http://cran.r-project.org/doc/manuals/R-lang.html#Classes) manual (that came with your version of R):


&gt; 2.2.4 Classes
&gt; 
&gt; R has an elaborate class system&lt;sup&gt;1&lt;/sup&gt;, principally controlled via the class attribute. This attribute is a character vector containing the list
&gt; of classes that an object inherits from. This forms the basis of the “generic methods” functionality in R.
&gt; 
&gt; This attribute can be accessed and manipulated virtually without restriction by users. There is no checking that an object actually contains the components that class methods expect. Thus, altering the class attribute should be done with caution, and when they are available specific creation and coercion functions should be preferred.

Every time I create a new workspace in Eclipse I have to turn off the spell checking via Preferences. (Preferences-&gt;General-&gt;Editors-&gt;Text Editors-&gt;Spelling-&gt;Enable Spell Checking)

This is very irritating. How do I turn off the spell checking for good? I.e. the spell checker is disabled when I create a new workspace and I can turn it on should I want to use it.


Turn off spell checking in Eclipse for good

I have the following situation:

- I created a `clone`(Y) from a main repository(X), because there were many people working on Y we didn&#39;t do any `rebase` but only `merge`s. When we want to deliver(`push`) Y to X we would like to do a `rebase` in order to have things nice and clean

The problem is that when doing `rebase` we are asked to do all the merges that we already did in the previous `merge` steps. Is there a solution to this, beside the one that means actually re-doing the merges? 

I expected it to be pretty straightforward since we already solved the conflicting merges.


git rebase after previous git merge

Two R questions:

1. What is the difference between the type (returned by `typeof`) and the class (returned by `class`) of a variable? Is the difference similar to that in, say, C++ language?
2. What are possible types and classes of variables?

Types and classes of variables

<p>Two R questions:</p>
<ol>
<li>What is the difference between the type (returned by <code>typeof</code>) and the class (returned by <code>class</code>) of a variable? Is the difference similar to that in, say, C++ language?</li>
<li>What are possible types and classes of variables?</li>
</ol>


All I am trying to do is to get the current class name, and java appends a useless non-sense **$1** to the end of my class name. How can I get rid of it and only return the actual class name?

    String className = this.getClass().getName();

Java - get the current class name?

Is there a way to circumvent the constructor `__init__` of a class in python?

Example:

    class A(object):	
	    def __init__(self):
    		print &quot;FAILURE&quot;
	
    	def Print(self):
    		print &quot;YEHAA&quot;

Now I would like to create an instance of `A`. It could look like this, however this syntax is not correct.

    a = A
    a.Print()

EDIT:

An even more complex example:

Suppose I have an object `C`, which purpose it is to store one single parameter and do some computations with it. The parameter, however, is not passed as such but it is embedded in a huge parameter file. It could look something like this:

    class C(object):
        def __init__(self, ParameterFile):
            self._Parameter = self._ExtractParamterFile(ParameterFile)
        def _ExtractParamterFile(self, ParameterFile):
            #does some complex magic to extract the right parameter
            return the_extracted_parameter

Now I would like to dump and load an instance of that object `C`. However, when I load this object, I only have the single variable `self._Parameter` and I cannot call the constructor, because it is expecting the parameter file. 

        @staticmethod
        def Load(file):
            f = open(file, &quot;rb&quot;)
            oldObject = pickle.load(f)
            f.close()

            #somehow create newObject without calling __init__
            newObject._Parameter = oldObject._Parameter
            return newObject

In other words, it is not possible to create an instance without passing the parameter file. In my &quot;real&quot; case, however, it is not a parameter file but some huge junk of data I certainly not want to carry around in memory or even store it to disc.

And since I want to return an instance of `C` from the method `Load` I do somehow have to call the constructor.

OLD EDIT:

A more complex example, which explains __why__ I am asking the question:

    class B(object):	
        def __init__(self, name, data):
            self._Name = name
            #do something with data, but do NOT save data in a variable

        @staticmethod
        def Load(self, file, newName):
            f = open(file, &quot;rb&quot;)
            s = pickle.load(f)
            f.close()

            newS = B(???)
            newS._Name = newName
            return newS

As you can see, since `data` is not stored in a class variable I cannot pass it to `__init__`. Of course I could simply store it, but what if the data is a huge object, which I do not want to carry around in memory all the time or even save it to disc?

Is there a way to instantiate a class without calling __init__?

I know that Python does not support method overloading, but I&#39;ve run into a problem that I can&#39;t seem to solve in a nice Pythonic way.

I am making a game where a character needs to shoot a variety of bullets, but how do I write different functions for creating these bullets? For example suppose I have a function that creates a bullet travelling from point A to B with a given speed. I would write a function like this:

    def add_bullet(sprite, start, headto, speed):
        # Code ...

But I want to write other functions for creating bullets like:

    def add_bullet(sprite, start, direction, speed):
    def add_bullet(sprite, start, headto, spead, acceleration):
    def add_bullet(sprite, script): # For bullets that are controlled by a script
    def add_bullet(sprite, curve, speed): # for bullets with curved paths
    # And so on ...

And so on with many variations. Is there a better way to do it without using so many keyword arguments cause its getting kinda ugly fast. Renaming each function is pretty bad too because you get either `add_bullet1`, `add_bullet2`, or `add_bullet_with_really_long_name`.

To address some answers:

1. No I can&#39;t create a Bullet class hierarchy because thats too slow. The actual code for managing bullets is in C and my functions are wrappers around C API.

2. I know about the keyword arguments but checking for all sorts of combinations of parameters is getting annoying, but default arguments help allot like `acceleration=0`


Python function overloading

I want to create a class in R, should I use S3 or S4 class?

I read a lot of different things about them, is there one superior to the other one?

class in R: S3 vs S4

I am learning Java recently, and I came across the notion of `package-private` classes, which is the default if we don&#39;t specify anything. But then I realized:

1. I seldom see the use of package-private class. Is there a reason for this, e.g., it has serious drawbacks, it is redundant, or simply I am not reading enough? Are there strong arguments for/against its usage?

2. If it is really not useful in most cases, why would it be the default?

3. In what situation should we use package-private in the real world? I.e., when would it become irreplaceable?

In other words, what are the major pros and cons of the default package-private modifier?

Pros and cons of package private classes in Java?

Is there a standardized way in R of measuring execution time of function?

Obviously I can take `system.time` before and after execution and then take the difference of those, but I would like to know if there is some standardized way or function (would like to not invent the wheel).

---

I seem to remember that I have once used something like below:

    somesysfunction(&quot;myfunction(with,arguments)&quot;)
    &gt; Start time : 2001-01-01 00:00:00  # output of somesysfunction
    &gt; &quot;Result&quot; &quot;of&quot; &quot;myfunction&quot;        # output of myfunction
    &gt; End time : 2001-01-01 00:00:10    # output of somesysfunction
    &gt; Total Execution time : 10 seconds # output of somesysfunction

Measuring function execution time in R

Does anyone know how to remove an entire column from a data.frame in R? For example if I am given this data.frame:

    &gt; head(data)
       chr       genome region
    1 chr1 hg19_refGene    CDS
    2 chr1 hg19_refGene   exon
    3 chr1 hg19_refGene    CDS
    4 chr1 hg19_refGene   exon
    5 chr1 hg19_refGene    CDS
    6 chr1 hg19_refGene   exon

and I want to remove the 2nd column.

Remove an entire column from a data.frame in R

I have a dataframe in R of the following form:

    &gt; head(data)
      Group Score Info
    1     1     1    a
    2     1     2    b
    3     1     3    c
    4     2     4    d
    5     2     3    e
    6     2     1    f

I would like to aggregate it following the `Score` column using the `max` function

    &gt; aggregate(data$Score, list(data$Group), max)

      Group.1         x
    1       1         3
    2       2         4

But I also would like to display the `Info` column associated to the maximum value of the `Score` column for each group. I have no idea how to do this. My desired output would be:

      Group.1         x        y
    1       1         3        c
    2       2         4        d

Any hint?

Aggregate a dataframe on a given column and display another column

Is there a way I can specify and get data from a web site URL on to a CSV file for analysis using R?

Access a URL and read Data with R

Is there a way I can make an alias, within R, that will execute `q()` and then restart a clean R session?

And yes, I am too lazy to type `q()` and then the letter `R` :)


Quit and restart a clean R session from within R?

In C (not C++/C#) how do I check if a variable is of a certain type?

For example, something like this:

    double doubleVar;
    if( typeof(doubleVar) == double ) {
        printf(&quot;doubleVar is of type double!&quot;);
    }

Or more general: How do I compare two types so that `compare(double1,double2)` will evaluate to true, and `compare(int,double)` will evaluate to false. Also I&#39;d like to compare structs of different composition as well.

Basically, I have a function that operates on variables of type &quot;struct a&quot; and &quot;struct b&quot;. I want to do one thing with the &quot;struct a&quot; variables and the other with the &quot;struct b&quot; variables. Since C doesn&#39;t support overloading and the `void` pointer losses its type information I need to check for type. BTW, what would be the sense in having a `typeof` operator, if you can&#39;t compare types?

&lt;hr/&gt;

The sizeof method seems to be a practical workaround solution for me. Thanks for your help. I still find it a bit strange since the types are known at compile time, but if I imagine the processes in the machine I can see, why the information is not stored in terms of types, but rather in terms of byte size. Size is the only thing really relevant besides addresses.


How do I check if a variable is of a certain type (compare two types) in C?

I have a question regarding using `intptr_t` vs. `long int`. I&#39;ve observed that incrementing memory addresses (e.g. via manual pointer arithmetic) differs by data type. For instance incrementing a char pointer adds 1 to the memory address, whereas incrementing an int pointer adds 4, 8 for a double, 16 for a long double, etc...

At first I did something like this:

	char myChar, *pChar;
	float myFloat, *pFloat;
	
	pChar = &amp;myChar;
	pFloat = &amp;myFloat;
	
	printf( &quot;pChar:  %d\n&quot;, ( int )pChar );
	printf( &quot;pFloat: %d\n&quot;, ( int )pFloat );
	
	pChar++;
	pFloat++;
	
	printf( &quot;and then after incrementing,:\n\n&quot; );
	printf( &quot;pChar:  %d\n&quot;, (int)pChar );
	printf( &quot;pFloat:	%d\n&quot;, (int)pFloat );

which compiled and executed just fine, but XCode gave me warnings for my typecasting: &quot;Cast from pointer to integer of different size.&quot;

After some googling and binging (is the latter a word yet?), I saw some people recommend using `intptr_t`:

    #include &lt;stdint.h&gt;
...
    
	printf( &quot;pChar:  %ld\n&quot;, ( intptr_t )pChar );
	printf( &quot;pFloat: %ld\n&quot;, ( intptr_t )pFloat );

which indeed resolves the errors. So, I thought, from now on, I should use `intptr_t` for typecasting pointers... But then after some fidgeting, I found that I could solve the problem by just replacing `int` with `long int`:

	printf( &quot;pChar:  %ld\n&quot;, ( long int )pChar );
	printf( &quot;pFloat: %ld\n&quot;, ( long int )pFloat );

So my question is, why is `intptr_t` useful, and when should it used? It seems superfluous in this instance. Clearly, the memory addresses for `myChar` and `myFloat` were just too big to fit in an `int`... so typecasting them to `long int`s solved the problem. 

Is it that sometimes memory addresses are too big for `long int` as well? Now that I think about it, I guess that&#39;s possible if you have &gt; 4GB of RAM, in which case memory addresses could exceed 2^32 - 1 (max value for unsigned long ints...) but C was created long before that was imaginable, right? Or were they that prescient?

Thanks!

Why / when to use `intptr_t` for type-casting in C?

Running Postgres 7.4 (Yeah we are in the midst of upgrading)

I need to store from 1 to 100 selected items into one field in a database. 98% of the time it&#39;s just going to be 1 item entered, and 2% of the time (if that) there will be multiple items.

The items are nothing more than a text description, (as of now) nothing more than 30 characters long.  They are static values the user selects.

Wanted to know the optimal column data type used to store the desired data. I was thinking BLOB but didn&#39;t know if this is a overkill. Maybe JSON?

Also I did think of ENUM but as of now I can&#39;t really do this since we are running Postgres 7.4

I also wanted to be able to easily identify the item(s) entered so no mappings or referencing tables.

How to store array or multiple values in one column

I have not found a good resource for using `interface{}` types. For example

    package main
    
    import &quot;fmt&quot;
    
    func weirdFunc(i int) interface{} {
    	if i == 0 {
    		return &quot;zero&quot;
    	}
    	return i
    }
    func main() {
    	var i = 5
    	var w = weirdFunc(5)
    
    	// this example works!
    	if tmp, ok := w.(int); ok {
    		i += tmp
    	}
    
    	fmt.Println(&quot;i =&quot;, i)
    }


Do you know of a good introduction to using Go&#39;s `interface{}`?

specific questions:

 - how do I get the &quot;real&quot; Type of w?
 - is there any way to get the string representation of a type?
 - is there any way to use the string representation of a type to
   convert a value?

How to determine an interface{} value&#39;s &quot;real&quot; type?

I&#39;ve been using the new `auto` keyword available in the C++11 standard for complicated templated types which is what I believe it was designed for. But I&#39;m also using it for things like:

    auto foo = std::make_shared&lt;Foo&gt;();

And more skeptically for:

    auto foo = bla(); // where bla() return a shared_ptr&lt;Foo&gt;

I haven&#39;t seen much discussion on this topic. It seems that `auto` could be overused since a type is often a form of documentation and sanity checks. Where do you draw the line in using `auto` and what are the recommended use cases for this new feature?

To clarify: I&#39;m not asking for a philosophical opinion; I&#39;m asking for the intended use of this keyword by the standard committee, possibly with comments on how that intended use is realized in practice.

Content Type	Original Author	Original Content on Stackoverflow
Question	Leo	View Question on Stackoverflow
Solution 1 - Class	diliop	View Answer on Stackoverflow
Solution 2 - Class	Dirk Eddelbuettel	View Answer on Stackoverflow

Types and classes of variables

Class Problem Overview

Class Solutions

Solution 1 - Class

Solution 2 - Class

git rebase after previous git merge

Turn off spell checking in Eclipse for good

Attributions