These are basically research topics, and the results are generally given in the form of conclusions, while the statistical data is hidden. One can have statistical analysis on their own data though.

For the benchmarks, better go through the implementation details.

The 3rd part of the question is a very subjective matter, and the actual intentions may never be known at the time of implementation. However, languages like perl do their best to implement highly optimized solutions to every operation.

Following might be of help:
Purely Functional Data Structures by Chris Okasaki
http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf

I&#39;ve looked at a dozen SO questions on this topic, and none of the answers have worked for me.  Maybe this will help get me back on the right path.

Imagine this setup:

![enter image description here][1]


I want to get the `center` coordinates of the UIButton relative to the UIView.

In other words, the UIButton center may be 215, 80 within the UITableViewCell, but relative to the UIView they should be more like 260, 165.  How do I convert between the two?

Here&#39;s what I&#39;ve tried:

    [[self.view superview] convertPoint:button.center fromView:button];  // fail
    [button convertPoint:button.center toView:self.view];  // fail
    [button convertPoint:button.center toView:nil];  // fail
    [button convertPoint:button.center toView:[[UIApplication sharedApplication] keyWindow]];  // fail

I could do it the hard way by looping through all of the button&#39;s superviews and adding up the x and y coordinates, but I suspect that&#39;s overkill.  I just need to find the right combination of covertPoint settings.  Right?

  [1]: http://i.stack.imgur.com/VcbWy.png

Using convertPoint to get the relative position inside a parent UIView

I have a ListView that should have the following layout in its rows:

    HEADER
    Text

`HEADER` should be static but the `Text` changes every few seconds.

I implemented it by populating a `String[] array`, pass it to an `ArrayAdapter` and set it every time the data changes:

    data_array = populateString();
    adapter = new ArrayAdapter&lt;String&gt;(this, android.R.layout.simple_list_item_1, android.R.id.text1,  data_array);
    listView.setAdapter(adapter);

My problem is that I do not know how to display the data in the format above.

Thanks in advance.

Android custom Row Item for ListView

Given a data structure specification such as a purely functional map with known complexity bounds, one has to pick between several implementations. There is some folklore on how to pick the right one, for example Red-Black trees are considered to be generally faster, but AVL trees have better performance on work loads with many lookups.

1. Is there a systematic presentation (published paper) of this knowledge (as relates to sets/maps)? Ideally I would like to see statistical analysis performed on actual software. It might conclude, for example, that there are N typical kinds of map usage, and list the input probability distribution for each.

2. Are there systematic benchmarks that test map and set performance on different distributions of inputs?

3. Are there implementations that use adaptive algorithms to change representation depending on actual usage?






Statistical performance of purely functional maps and sets

Given a data structure specification such as a purely functional map with known complexity bounds, one has to pick between several implementations. There is some folklore on how to pick the right one, for example Red-Black trees are considered to be generally faster, but AVL trees have better performance on work loads with many lookups.
<ol>
<li>
Is there a systematic presentation (published paper) of this knowledge (as relates to sets/maps)? Ideally I would like to see statistical analysis performed on actual software. It might conclude, for example, that there are N typical kinds of map usage, and list the input probability distribution for each.
</li>
<li>
Are there systematic benchmarks that test map and set performance on different distributions of inputs?
</li>
<li>
Are there implementations that use adaptive algorithms to change representation depending on actual usage?
</li>
</ol>

I came across this good question, which is similar but not at all same since it talks about Java, which has different implementation of hash-tables, by virtue of having synchronized accessor /mutators:
https://stackoverflow.com/questions/40471/differences-between-hashmap-and-hashtable

So what is the difference in C++ implementation of `set` and `unordered_set`? 
This question can be of course extended to `map` vs `unordered_map` and so on for other C++ containers.

Here is my initial assessment:

`set`: While the standard doesn&#39;t explicitly ask it to be implemented as trees, the time-complexity constraint asked for its operations for find/insert, means it will always be implemented as a tree.
Usually as RB tree (as seen in GCC 4.8), which is height-balanced.
Since they are height balanced, they have predictable time-complexity for `find()`

Pros: Compact (compared to other DS in comparison)

Con: Access time complexity is O(lg n)

`unordered_set`: While the standard doesn&#39;t explicitly asks it to be implemented as trees, the time-complexity constraint asked for its operations for find/insert, means it will always be implemented as a hash-table.

Pros:

 1. Faster (promises amortized O(1) for search)
 2. Easy to convert basic primitives to thread-safe, as compared to tree-DS

Cons:

 1. Look up not guaranteed to be O(1). Theoretical worst case is O(n).
 2. Not as compact as tree (for practical purposes load factors is never 1).

Note:
The O(1), for hashtable comes from the assumption that there are no collision. Even with load-factor of .5, every second variable insertion is leading to collision.
It could be observed that the load-factor of hash-table is inversely proportional to the number of operations required for accessing a element in it. More we reduce #operations, sparser hash-table. When the element stored are of size comparable to pointer, then overhead is quite significant.

**Did I miss any difference between map/set for performance analysis that one should know?**

what is the difference between set and unordered_set in C++?

Can someone please explain what the main differences between these two data structures are?  I&#39;ve been trying to find a source online that highlights the differences/similarities, but I haven&#39;t found anything too informative.  In what cases would one be preferred over the other?  What practical situations make one &quot;better&quot; to use than the other?

Difference between red-black trees and AVL trees

I am new to firebase and I want to know what&#39;s the best way of structuring data on it.

I have a simple example:

There are Applicants and Applications on my project. 1 applicant can have several applications. How can I relate this 2 objects on firebase? Does it work like a relational database? Or the approach needs to be completely different in terms of data design? 



What&#39;s the best way of structuring data on firebase?

I&#39;m new in Firebase and nosql so bear with me to use reference to sql.
So my question is how to structure the data in firebase?

In firebase, is that mean every &quot;new firebase&quot; = &quot;new Database&quot; or &quot;table&quot; in mysql?

If in my real time web app, I have users and comments.
In mysql, I will create a users and a comments table then link them together.

How do I structure this in firebase?


Firebase data structure and url

How can one neatly represent a [graph][1] in [Python][2]? (Starting from scratch i.e. no libraries!)&lt;br/&gt;What data structure (e.g. dicts/tuples/dict(tuples)) will be fast but also memory efficient?&lt;br/&gt;One must be able to do various graph [operations][3] on it.&lt;br/&gt;&lt;br/&gt;
As pointed out, the various [graph representations][4] might help. How does one go about implementing them in Python?&lt;br/&gt;&lt;br/&gt;As for the libraries, [this question][5] has quite good answers.


  [1]: https://en.wikipedia.org/wiki/Graph_%28data_structure%29
  [2]: https://en.wikipedia.org/wiki/Python_(programming_language)
  [3]: https://en.wikipedia.org/wiki/Graph_%28data_structure%29#Operations
  [4]: https://en.wikipedia.org/wiki/Graph_(abstract_data_type)#Representations
  [5]: https://stackoverflow.com/questions/606516/python-graph-library

Representing graphs (data structure) in Python

I was looking through my codebase today and found this:

    def optionsToArgs(options, separator=&#39;=&#39;):
        kvs = [
            (
                &quot;%(option)s%(separator)s%(value)s&quot; %  
                {&#39;option&#39; : str(k), &#39;separator&#39; : separator, &#39;value&#39; : str(v)}
            ) for k, v in options.items()
        ]
        return list(
            reversed(
                list(
                        (lambda l, t: 
                            (lambda f: 
                                (f((yield x)) for x in l)
                            )(lambda _: t)
                        )(kvs, &#39;-o&#39;)
                    )
                )
            )

It seems to take a dict of parameters and turn them into a list of parameters for a shell command. It looks like it&#39;s using yield inside a generator comprehension, which I thought would be impossible...?

    &gt;&gt;&gt; optionsToArgs({&quot;x&quot;:1,&quot;y&quot;:2,&quot;z&quot;:3})
    [&#39;-o&#39;, &#39;z=3&#39;, &#39;-o&#39;, &#39;x=1&#39;, &#39;-o&#39;, &#39;y=2&#39;]


How does it work?


How does this lambda/yield/generator comprehension work?

I have heard the term &quot;coalgebras&quot; several times in functional programming and PLT circles, especially when the discussion is about objects, comonads, lenses, and such. Googling this term gives pages that give mathematical description of these structures which is pretty much incomprehensible to me. Can anyone please explain what coalgebras mean in the context of programming, what is their significance, and how they relate to objects and comonads?

What does &quot;coalgebra&quot; mean in the context of programming?

I wonder what the difference is between those operations in Scheme. I have seen similar questions in Stack Overflow but they are about Lisp, and there is not a comparison between three of those operators.

I am writing the different types of commands in Scheme, and I get the following outputs:

    (eq? 5 5) --&gt;#t
    (eq? 2.5 2.5) --&gt;#f
    (equal? 2.5 2.5) --&gt; #t
    (= 2.5 2.5) --&gt; #t

Why is this the case?

What is the difference between eq?, eqv?, equal?, and = in Scheme?

Consider a single-linked list. It looks something like

    data List x = Node x (List x) | End

It is natural to define a folding function such as

    reduce :: (x -&gt; y -&gt; y) -&gt; y -&gt; List x -&gt; y

In a sense, `reduce f x0` replaces every `Node` with `f` and every `End` with `x0`. This is what the Prelude refers to as a _fold_.

Now consider a simple binary tree:

    data Tree x = Leaf x | Branch (Tree x) (Tree x)

It is similarly natural to define a function such as

    reduce :: (y -&gt; y -&gt; y) -&gt; (x -&gt; y) -&gt; Tree x -&gt; y

Notice that _this_ reduction has a quite different character; whereas the list-based one is inherently sequential, this new tree-based one has more of a divide-and-conquer feel to it. You could even imagine throwing a few `par` combinators in there. (Where would you put such a thing in the list version?)

My question: Is this function still classified as a &quot;fold&quot;, or is it something else? (And if so, what is it?)

Basically whenever anybody talks about folding, they always talk about folding _lists_, which is inherently sequential. I&#39;m wondering whether &quot;sequential&quot; is part of the definition of what a fold is, or whether this is merely a coincidental property of the most commonly-used example of folding.


What constitutes a fold for types other than list?

Is there a way to compare two functions for equality? For example, `(λx.2*x) == (λx.x+x)` should return true, because those are obviously equivalent. 

How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?

In `R`, it is possible to perform two-sample one-tailed t-test simply by using

    &gt; A = c(0.19826790, 1.36836629, 1.37950911, 1.46951540, 1.48197798, 0.07532846)
    &gt; B = c(0.6383447, 0.5271385, 1.7721380, 1.7817880)
    &gt; t.test(A, B, alternative=&quot;greater&quot;)
    
    	Welch Two Sample t-test
    
    data:  A and B 
    t = -0.4189, df = 6.409, p-value = 0.6555
    alternative hypothesis: true difference in means is greater than 0 
    95 percent confidence interval:
     -1.029916       Inf 
    sample estimates:
    mean of x mean of y 
    0.9954942 1.1798523 

In Python world, `scipy` provides similar function [ttest_ind][1], but which can only do two-tailed t-tests. Closest information on the topic I found is [this][2] link, but it seems to be rather a discussion of the policy of implementing one-tailed vs two-tailed in `scipy`.

Therefore, my question is that does anyone know any examples or instructions on how to perform one-tailed version of the test using `numpy/scipy`?

  [1]: http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_ind.html#scipy.stats.ttest_ind
  [2]: http://scipy-user.10969.n7.nabble.com/scipy-stats-one-sided-two-sided-less-greater-signed-td3730.html#a31795926

How to perform two-sample one-tailed t-test with numpy/scipy

I do this `linear regression` with `StatsModels`:

    import numpy as np
    import statsmodels.api as sm
    from statsmodels.sandbox.regression.predstd import wls_prediction_std

    n = 100

    x = np.linspace(0, 10, n)
    e = np.random.normal(size=n)
    y = 1 + 0.5*x + 2*e
    X = sm.add_constant(x)

    re = sm.OLS(y, X).fit()
    print(re.summary())

    prstd, iv_l, iv_u = wls_prediction_std(re)

My questions are, `iv_l` and `iv_u` are the upper and lower *confidence intervals* or *prediction intervals*? 

How I get others? 

I need the confidence and prediction intervals for all points, to do a plot.

confidence and prediction intervals with StatsModels

I have some  questions about [boxplots][1] in matplotlib:

**Question A**. What do the markers that I highlighted below with **Q1**, **Q2**, and **Q3** represent? I believe **Q1** is maximum and **Q3** are outliers, but what is **Q2**?

&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; ![enter image description here][2]

**Question B** How does matplotlib identify **outliers**? (i.e. how does it know that they are not the true `max` and `min` values?)


  [1]: http://matplotlib.org/examples/pylab_examples/boxplot_demo.html
  [2]: http://i.stack.imgur.com/FBqdp.png

Boxplots in matplotlib: Markers and outliers

When I try to define my linear model in R as follows:

    lm1 &lt;- lm(predictorvariable ~ x1+x2+x3, data=dataframe.df)

I get the following error message:

    Error in `contrasts&lt;-`(`*tmp*`, value = contr.funs[1 + isOF[nn]]) : 
    contrasts can be applied only to factors with 2 or more levels 

Is there any way to ignore this or fix it? Some of the variables are factors and some are not.



Error in contrasts when defining a linear model in R

I notice that 

    In [30]: np.mean([1, 2, 3])
    Out[30]: 2.0
    
    In [31]: np.average([1, 2, 3])
    Out[31]: 2.0

However, there should be some differences, since after all they are two different functions.

**What are the differences between them?**


Content Type	Original Author	Original Content on Stackoverflow
Question	t0yv0	View Question on Stackoverflow
Solution 1 - Data Structures	Sanjay Verma	View Answer on Stackoverflow

Statistical performance of purely functional maps and sets

Data Structures Problem Overview

Data Structures Solutions

Solution 1 - Data Structures

Android custom Row Item for ListView

Using convertPoint to get the relative position inside a parent UIView

Attributions