text:
# Does my data come from a gamma or beta distribution? [closed]

I have data and I want to ascertain whether it is beta or gamma distribution.

Once I know what the distribution is, how do I find out what the parameters are?

• Can you say anything about your data, such as where they come from, or if they're bound by 0 & 1? – gung - Reinstate Monica May 11 '12 at 16:49
• Why do you think it's either gamma or beta distributed? – jbowman May 11 '12 at 18:18
• Have you looked at qqplots of your data against those densities? – Seth May 11 '12 at 18:29
• The Beta distribution is restricted to $(0,1)$ so it should be rather obvious when looking at your data, assuming those are the only two possibilities.... – Xi'an May 12 '12 at 19:37

You can use the free statistical program R, available at http://www.r-project.org/, to analyze your data. You state that you want to determine how your data are distributed. You guess that your data either conform to a beta or a gamma distribution. You provide no information about your data and do not speculate that it could conform to one of the many other probability distribution types, so I'll just briefly discuss the two distributions that you mention in my answer. I suppose the most logical thing to do first would be to simply plot your data on a histogram or density plot to facilitate visual inspection.

Example 1: Beta Distribution

The beta distribution is a family of continuous probability distributions defined on the interval (0, 1).

You provide no example data in your question, so we will have to make some up for this example. First, let's make some randomly generated dummy data that conform to a beta distribution. We can use the rbeta() command to do this. Type help(rbeta) into R to learn how to use this function.

## Generate 10,000 data points and save them as an object called "temp".
temp <- rbeta(10000, shape1 = 1, shape2 = 1, ncp = 0)

Now, let's double check that our data are bound by zero and one. We can use the summary() command to do this.

## Find maximum and minimum value of the data.
summary(temp)

Now, let's plot the data on a histogram for visual inspection.

## Plot the data on a histogram.
hist(temp)

You could alternatively make a density plot of the data, which for practical purposes is the same thing.

## Make density plot.
plot(density(temp))

I suppose you can take the mean and variance of your data and use them to calculate the parameters of a beta distribution. (Before jumping to this step, you should probably do more descriptive analyses, including looking at the qqplots as suggested by Seth, above). The below function, copied directly from Max's example on this page, should provide estimates of the parameters.

## Calculate mean and variance of the data.
mu <- mean(temp)
var <- var(temp)

## Define function to estimate parameters of a beta distribution.
estBetaParams <- function(mu, var) {
alpha <- ((1 - mu) / var - 1 / mu) * mu ^ 2
beta <- alpha * (1 / mu - 1)
return(params = list(alpha = alpha, beta = beta))
}

## Apply function to your data.
estBetaParams(mu, var)

Example 2: Gamma Distribution

The gamma distribution is a two-parameter family of continuous probability distributions.

First, let's make some randomly generated dummy data that conform to a gamma distribution. We can use the rgamma() command to do this.

## Generate 10,000 data points and save them as an object called "temp".
temp <- rgamma(10000, shape = 1, rate = 10, scale = 1/rate)

## Plot the data on a histogram for visual inspection.
hist(temp)

To estimate the gamma distribution parameters, you can use the MASS library, explained at this website. After installing and loading the MASS library into R, type help(fitdistr) for more information.

• beta is defined on the interval $(0,1)$ or $[0,1]$ ? – juanpablo Aug 12 '13 at 14:21

format: plain


text:
# Showing a function is differentiable

Supose $p>1$ and $f,g\in L^p(\mathbb{R})$. Let $H(s)=\int_\mathbb{R}|f(x)+s\cdot g(x)|^p\mathrm{d}x$ for $s\in \mathbb{R}$. Show that $H$ is differentiable and find its derivative.

I've tried using the definition of derivative but haven't made any progress.

-
It looks like there's an exponent missing in the integrand. You probably want to consider $H(s) = \int_\mathbb{R} |f(x) + s g(x)|^{\color{red}{p}}\,dx$. If so, differentiate under the integral sign (argue why this is allowed!) and use that $s \mapsto |s|^p$ has derivative $s \mapsto p|s|^{p-1} \operatorname{sign}{(s)}$. –  t.b. Jan 12 '12 at 5:01
@t.b. You're right about the exponent, it's fixed now. Thanks for the hint! –  Iksander Jan 12 '12 at 6:15


text:
Imagine that you were charged with finishing a task started by your colleague. He or she implemented it just before leaving for a vacation. Now it is your job to finish and release it.

Example: To make this example more practical, let’s say that the task is to count reactions that are stored in pageReactionsRepository. This is your colleague solution implemented in Kotlin:

suspend fun getReactionsForPage(pageKey: String, userUuid: String?): PageReactionsResponse =
pageReactionsRepository.getPageReactions(pageKey)
.let { reactions ->
PageReactionsResponse(
pageKey = pageKey,
reactionsCount = emptyReactionsMap + reactions.groupingBy { it.reaction }.eachCount(),
userChoice = userUuid?.let { reactions.find { it.userUuid == userUuid } }?.reaction
)
}

Is this solution correct? Think about it for a minute. After analysing above code you might conclude that this solution seems correct, but are you sure about it? An even better question would be: what is your degree of sureness that this solution is correct? There is one thought experiment that help us establish that: How much money would you bet on this function being correct?

### Releasing is always a bet

Think of a release as a bet. You need to put money on correctness, and if you are wrong, you lose it all. It won’t be a fair bet, though. If you are right, you win nothing. If you are wrong, you need to pay. A third alternative is to spend more of your precious time and investigate.

So now, would you bet 10 cents on this solution? Yeah, why not. Would you bet 10 dollars? Some readers probably would, but I wouldn’t. From my observations, most experienced developers wouldn’t either as we’ve seen enough good looking code with a surprising outcome (we sometimes collect such snippets as puzzlers). Would you bet 1000 dollars on this solution working 100% correctly? I think no sane person would.

This game design is no coincidence. It simulates you from your employer’s perspective. Assuming there are no other verification mechanisms, this is how it would work — on the one hand, you can spend more time (which is valuable); on the other, a bug in production can be costly. Sure, in most cases, there are some testers on the way. But depending too heavily on testers is dangerous, and the fact that we missed a bug is already a risk. We will talk about it later.

### The stake is different in different products and functionalities

Most mistakes can be fixed. The highest costs are:

• Users’ discontent that can negatively influence their behavior and your company image.

This cost is much smaller for small companies or start-ups. It is also much smaller for internal products (for our employees). This is why small companies often care less about proper testing. Big products known publicly are under much higher pressure. At Allegro some mistakes might cost the company thousands or even millions of dollars. This is why we take testing seriously.

### We build sureness via different forms of checking

So let’s assume this is a 100 dollars bet. What would you do to make sure it works fine? This is where we start the process of checking.

 Note: Checking and testing are not the same, but those two terms are often confused. People often call testing what should be called checking (https://www.infoq.com/news/2009/12/testing-or-checking/). I will not play language nazi here, and I stick with the term “software testing” as a subcategory of checking.

The first intuitive step is to check it out manually. The steps are:

1. Use this functionality and see how it behaves.
2. If it seems correct, think about possible problems and check them out. So we try to emulate a situation that might not be handled well, and we see what happens. If anything catches our attention, we stop and try to fix it. If not, we feel more confident that our functionality works fine.

This is what many programmers do, but it works well only in the short term. The problem is that it does not scale well.

### We can still lose the bet in the future — we need automatic testing

When I was still a student, a friend of mine, who worked in a big corporation, complained that other people write some components, and they do not leave any tests. “This is extremely immature,” he said, “Later, I need to touch it to introduce some change, and I have no idea if I broke something or not.” This system couldn’t be tested manually. It was (and is) too big, and I am not sure if there is a single person who understands it all. Even if it could, it would take a preposterous amount of time for each small change.

This is the answer to the question why hiring many manual testers is not a good long-term solution (even though it is practiced by many companies in Poland). It does not scale well. The bigger your system, the more manual testers you need to maintain to just check regression.

We need automatic testing — testing we can run again and again and have it check all main functionalities.

It is not free as it needs to be written, and it needs to be maintained (when we change logic in our system, we need to update tests as well). However, in the end, if your project is big and changes over time, it will surely pay off.

### Lack of tests leads to anxious developers and terrible code

Having a properly tested code is very important for us, developers. Without it, we feel anxious when operating on it. For a good reason: a small change might break who knows what. This has further consequences. When developers are worried about touching the code, and the project is too big for them to comprehend and test it all manually, they will make minimal changes possible. They will not refactor the legacy code. As a consequence:

• Components look worse and worse over time.
• We will soon have outdated system design, not reflecting how our system works now.
• Code will be less and less understandable by developers.

### Testing takes time and skills

On the other hand, writing tests has costs too:

• Proper testing takes a lot of time.
• Testing requires adjustments in architecture, which is both positive (it is often cleaner) and negative (it is often more complicated).
• Testing well is hard and needs to be learned. It is easy to write tests that test little and constrain our code a lot. It is hard to do the other way around.

It is also said, that if we first think about tests before implementation, we design both tests and components differently. Probably in a better way, but who knows for sure.

Testing is not easy, but it is worth to learn it. It takes time, but it will pay off later. We need to learn to write proper tests in an appropriate amount, so they serve us well.

### We need to stay in touch with tests

Another trick teams do when developers do not want to write tests is hiring a tester to write automatic tests. It works… to a certain degree. He might be very helpful by writing end-to-end tests for you, but they are not enough, as we will see later. We should also not entirely give up on testing ourselves.

As creators, we need to know our product and how to use it well. If we don’t, we lose contact with it. This should never happen for many reasons (decision-making, system design, operating on the project). Manual testing is one of the best ways to stay in touch with the system.

### Do not send unchecked functionality to a tester

One terrible mistake I see some developers doing is sending unchecked code to testers without even running it. It is nearly sure it will be back with some mistakes. The time developer saved on not checking will be wasted on getting back to the task and starting it again. He also wasted another person’s time and increased the risk of a problem getting released to production. A tester should be the second person to check something out. Not the only one. This should never happen.

### We need to unit test components ourselves

A tester can write end-to-end tests for the system. Having it well tested, we can have some degree of sureness our system behaves correctly. It does not mean that its components work correctly, though.

A few times, I had a funny situation where mistakes in 2 components canceled each other out, and the system as a whole worked fine. After fixing one of them, unexpected behavior revealed itself. Another common problem is that component is not implemented correctly, but the way we use it does not reveal it. However, if we use this component somewhere else, we might have a problem. This causes a cascade of problems. Refactorization then might be much harder.

Another thing is that when we test components, we know better what extreme situations might break them.

Finally, unit tests are generally much faster than other kinds of tests, and they are an important tool we should use when we develop a solution to check out our code’s correctness.


text:
# Zero Point Fluctuations

The total energy of a mode in a quantum mechanical resonator is given by $E_n ~=~ (n+ 1/2)hf$ where $n$ is the number of modes. So when there are no modes or vibrations, i.e. $n=0$, the energy is called the zero-point energy.

What I don't understand is, if there are no modes, then what is this energy associated with? So what exactly is a mode? Also, is there a way of measuring this zero-point fluctuations? Why is the 1/2 photon introduced?

-
The average energy is zero, but the variance need not be zero. –  Antillar Maximus Oct 31 '12 at 20:28
If you like this question you may also enjoy reading this post. –  Qmechanic Oct 31 '12 at 21:18

The zero-point energy for the quantum mechanical harmonic oscillator can be related to the Heisenberg uncertainty principle (HUP). A bit oversimplified, the point is intuitively that if the mechanical energy

$$H~=~\frac{p^2}{2m}+\frac{1}{2}m\omega^2 q^2, \qquad \omega ~:=~ 2\pi f,$$

is zero, then the position $q$ and the momentum $p$ must also both be zero, in contradiction with the HUP. Instead both $q$ and $p$ "fluctuate/are fuzzy" in the ground state, thereby producing the zero-point energy.

The zero-point energy is e.g. important to theoretically explain the Casimir effect, which in turn has been experimentally observed.

In cosmology, zero-point energy is related to the cosmological constant.

-
Qmechanic and @Foster Boondoggle- Thanks. It is starting to make sense to an extent. [calphysics.org/zpe.html] This helped as well. Thank you so much. –  Spaceman Spiff Oct 31 '12 at 21:02
@Spaceman Spiff: Be aware that the Calphysics.org site, you linked to, is controversial non-mainstream reading. Read e.g. Wikipedia instead. –  Qmechanic Nov 1 '12 at 2:27
Are there any other phenomena that definitely require zero point energy? Casimir force can apparently be described without the use of it. –  Daniel R Jul 15 '14 at 0:19

It's associated with the confinement of the particle. As the coefficient of the quadratic term in the harmonic potential goes to zero, the particle becomes less & less localized and the the zero point energy drops accordingly. It can be as small as you want.

When you speak of photons, now you're referring to QFT and the energy in a mode of the EM field. There's no 1/2 a photon. There's an arbitrary normalization of the zero point of the vacuum field energy but no one knows how this relates to the cosmological constant -- in QFT it's arbitrary, and there are only semiclassical arguments of questionable rigor for how it should couple to the curvature tensor in GM.

Incidentally, you can also derive the Casimir effect without any reference to zero modes of the field, as the analog of the van der Waals force between polarizable atoms/molecules. The wikipedia page has the details.

-

Choice of the zero-point energy is similar to choice of zero of the potential - it is rather arbitrary. One can safely put it equal to zero. However one should not understand it as a "zero-motion". The motion in the ground state exists (HUP) and it determines the size of systems created by bound particles (like atomic size, etc).

-


text:
## Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2

Publikation: Bidrag til tidsskrift/Konferencebidrag i tidsskrift /Bidrag til avisTidsskriftartikelForskningpeer review

### Standard

I: Advances in Theoretical and Mathematical Physics, Bind 19, Nr. 3, 01.01.2015, s. 673-699.

Publikation: Bidrag til tidsskrift/Konferencebidrag i tidsskrift /Bidrag til avisTidsskriftartikelForskningpeer review

### Harvard

Gholampour, A & Sheshmani, A 2015, 'Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2', Advances in Theoretical and Mathematical Physics, bind 19, nr. 3, s. 673-699. https://doi.org/10.4310/ATMP.2015.v19.n3.a4

### APA

Gholampour, A., & Sheshmani, A. (2015). Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2. Advances in Theoretical and Mathematical Physics, 19(3), 673-699. https://doi.org/10.4310/ATMP.2015.v19.n3.a4

### Vancouver

Gholampour A, Sheshmani A. Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2. Advances in Theoretical and Mathematical Physics. 2015 jan 1;19(3):673-699. https://doi.org/10.4310/ATMP.2015.v19.n3.a4

### Author

Gholampour, Amin ; Sheshmani, Artan. / Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2. I: Advances in Theoretical and Mathematical Physics. 2015 ; Bind 19, Nr. 3. s. 673-699.

### Bibtex

@article{2011fccd4cf047af90ba1e235c0e303a,
title = "Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2",
abstract = "Let X be the total space of the canonical bundle of P2. We study the generalized Donaldson-Thomas invariants defined in [JS11] of the moduli spaces of the 2-dimensional Gieseker semistable sheaves on X with first Chern class equal to k times the class of the zero section of X. When k = 1, 2, or 3, and semistability implies stability, we express the invariants in terms of known modular forms. We prove a combinatorial formula for the invariants when k = 2 in the presence of the strictly semistable sheaves, and verify the BPS integrality conjecture of [JS11] in some cases.",
author = "Amin Gholampour and Artan Sheshmani",
year = "2015",
month = jan,
day = "1",
doi = "10.4310/ATMP.2015.v19.n3.a4",
language = "English",
volume = "19",
pages = "673--699",
journal = "Advances in Theoretical and Mathematical Physics",
issn = "1095-0761",
publisher = "International Press",
number = "3",

}

### RIS

TY - JOUR

T1 - Generalized Donaldson-Thomas invariants of 2-dimensional sheaves on local P2

AU - Gholampour, Amin

AU - Sheshmani, Artan

PY - 2015/1/1

Y1 - 2015/1/1

N2 - Let X be the total space of the canonical bundle of P2. We study the generalized Donaldson-Thomas invariants defined in [JS11] of the moduli spaces of the 2-dimensional Gieseker semistable sheaves on X with first Chern class equal to k times the class of the zero section of X. When k = 1, 2, or 3, and semistability implies stability, we express the invariants in terms of known modular forms. We prove a combinatorial formula for the invariants when k = 2 in the presence of the strictly semistable sheaves, and verify the BPS integrality conjecture of [JS11] in some cases.

AB - Let X be the total space of the canonical bundle of P2. We study the generalized Donaldson-Thomas invariants defined in [JS11] of the moduli spaces of the 2-dimensional Gieseker semistable sheaves on X with first Chern class equal to k times the class of the zero section of X. When k = 1, 2, or 3, and semistability implies stability, we express the invariants in terms of known modular forms. We prove a combinatorial formula for the invariants when k = 2 in the presence of the strictly semistable sheaves, and verify the BPS integrality conjecture of [JS11] in some cases.

UR - http://www.scopus.com/inward/record.url?scp=84946547014&partnerID=8YFLogxK

U2 - 10.4310/ATMP.2015.v19.n3.a4

DO - 10.4310/ATMP.2015.v19.n3.a4

M3 - Journal article

AN - SCOPUS:84946547014

VL - 19

SP - 673

EP - 699

JO - Advances in Theoretical and Mathematical Physics

JF - Advances in Theoretical and Mathematical Physics

SN - 1095-0761

IS - 3

ER -


text:
# Separate as a Pattern

Here’s another one of those situations that comes up often enough at work that it seems like it should be a recognized pattern. But then when I try to think how to really generalize it, I come up empty-handed, so I suppose that’s why it isn’t. Feels like a pattern; might not be general enough to be.

Anyway, it’s where you have a list of items that are already in sequence, and you only want a subset of those items. So far so filter, amirite? Or … so far so list comprehension.

So here’s the catch. Rather than returning a single list of all the items that passed my filter, I want the separations preserved. That is, I want a list of lists, each member of which is a list of consecutive items that passed the filter. That’s why it isn’t as simply as using a filter. Or a list comprehension. Because I need to "keep ‘em separated."

I’m going to call this separate, by the way. As an illustrative example, say I have a list of integers (all examples are in Coffeescript and may make use of the excellent RamdaJS library):

nums = [1,2,4,6,3,5,7,9,8,10]

And say I want only the evens. With a normal filter, I’d get this:

nums = [1,2,4,6,3,5,7,9,8,10]
evens = R.filter(even, nums)
# [2,4,6,8,10]

And of course it’s just as easy with a list comprehension:

nums = [1,2,4,6,3,5,7,9,8,10]
evens = (e for e in nums when even(e))
# [2,4,6,8,10]

What I want is a function separate that does this instead:

nums = [1,2,4,6,3,5,7,9,8,10]
evens = separate(even, nums)
# [[2,4,6],[8,10]]

Right out of the gate, we can see this is some form of reduce operation – because it doesn’t just exclude values, it also transforms the output. And it’s not a compose, because it isn’t like we first apply the filter and then the transformation. Nope – the transformation is part of the filter. Or something.

Really, what we need is some kind of stateful reduce – a reduce function that behaves differently when we transition from items in the seuqence that pass the filter to items in the sequence that don’t.

Welp, here’s the obvious first pass:

nums = [1,2,4,6,3,5,7,9,8,10]
make_reducer = (filter_function) ->
(accumulator, item) ->
if filter_function(item)
accumulator.push item
else
accumulator

reduce_function = make_reducer(even)
evens = R.reduce(reduce_function, [], nums)
# [2,4,6,8,10]

But of course, this is just filter in another form. To add the state(fulness), I need my accumulator to keep track of two things, really. It needs to keep a record of the final list of lists that will be returned at the end, and it also needs to keep a record of the current series of items that pass the filter, if there is one. Well, that sounds easy! Instead of a single list, the accumulator should be two lists – one that holds the final result, and one that holds the temporary accumulator for subsequences.

nums = [1,2,4,6,3,5,7,9,8,10]
make_reducer = (filter_function) ->
(accumulator, item) ->
if filter_function(item)
accumulator[1].push item
else if accumulator[1].length > 0
accumulator[0].push accumulator[1]
accumulator[1] = []
accumulator

reduce_function = make_reducer(even)
evens = R.reduce(reduce_function, [[],[]], nums)
# [[[2,4,6]],[8,10]]

Now the logic is a little more complicated. Just like before, if we encounter an item that passes the filter, we simply slap it onto the accumulator. Only now, "the accumulator" is "the temporary accumulator for subsequences," which I’ve arbitrarily decided is the second list.

If we encounter an item that does not pass the filter, well, one of two things could be true. Either we’ve come to the end of a sequence of items that needs to be pushed onto the final accumulator … OR, we haven’t, and we do nothing. The else if clause handles for the case where we’ve just reached the end of a sequence of consecutive filter-passing items.

But this isn’t quite finished, and if you look at the output (in the comment at the bottom) you’ll probably be able to guess why.

Indeed … this code only pushes the temporary accumulator onto the return accumulator after we transition to a sequence of items that don’t pass the filter. Implication being: if you end on an item that passes the filter, it never gets glommed onto the final return accumulator. Oops.

So, we actually need to wrap all this in a function that checks for that.

Here’s my final version:

nums = [1,2,4,6,3,5,7,9,8,10]
make_reducer = (filter_function) ->
(accumulator, item) ->
if filter_function(item)
accumulator[1].push item
else if accumulator[1].length > 0
accumulator[0].push accumulator[1]
accumulator[1] = []
accumulator

final_reduction = (acc) ->
if acc[1].length > 0
acc[0].push acc[1]
acc[0]

reduce_function = make_reducer(even)
evens = final_reduction(R.reduce(reduce_function, [[],[]], nums))
# [[2,4,6],[8,10]]

To make it a bit more idiomatic RamdaJS, you might do this:

nums = [1,2,4,6,3,5,7,9,8,10]
make_reducer = (filter_function) ->
(accumulator, item) ->
if filter_function(item)
accumulator[1].push item
else if accumulator[1].length > 0
accumulator[0].push accumulator[1]
accumulator[1] = []
accumulator

final_reduction = (acc) ->
if acc[1].length > 0
acc[0].push acc[1]
acc[0]

reduce_function = make_reducer(even)
even_sequences = R.compose(final_reduction, R.reduce(reduce_function, [[],[]]))
evens = even_sequences(nums)
# [[2,4,6],[8,10]]

And of course that makes it obvious how to abstract away the particulars to get separate:

separate = (filter_function) -> R.compose(final_reduction, R.reduce(make_reducer(filter_function), [[],[]]))

Now it’s in a form where we just pass in whatever the filter is, and it constructs the function we need! So, the following code would print out the answer from before:

nums = [1,2,4,6,3,5,7,9,8,10]
evens = separate(even)
console.log evens(nums)

(The definition of even was never given and is left as an exercise for the reader. Heh, heh. Don’t stay up too late…)


text:
# My upvoting policy

Some time ago I decided to employ a policy for upvoting the questions:

• When I answer the question, it means that it was worth answering, so I automatically upvote it. There are some minor exceptions when there are issues with the question or it doesn't show much research from OP, but I still decide to answer with no +1, but those are rare.
• I upvote all the questions by new users if they follow some minimum quality standards.

Why? It encourages participation. It also promotes visibility for the question (both psychologically "others voted for it" and in terms of the recommender system behind it). The +1's also come with moderation privileges on the site, so we have more people that vote, edit, create tags, etc, so the site works better as a whole.

Just wanted to share it.

• It is interesting that our Tour does not suggest any criteria for upvoting. Apr 13 at 14:01
• @RichardHardy personally, I wouldn't find such criteria neither needed nor useful. It is up to every user themselves to vote how and on whatever they want.
– Tim Mod
Apr 13 at 14:03
• Sure, one can think that way. But I think I remember there being some criteria previously, and now they seem to have been removed. Or am I mistaken? Apr 13 at 14:08
• @kjetilbhalvorsen I admit that I probably should upvote questions more often than I do. However, I participate in CV and SO primarily to support my R packages, and sometimes I can tell just enough in a question to know that the person posting the question does not understand what they are doing. In such cases, I am able to answer and try to set them straight. I will try to remember to upvote reasonable questions. However, I will not upvote a question that reveals that the asker is lost at sea and doing things completely wrong. And I did not appreciate your policing me on this recently. Apr 27 at 19:18

I have been using a similar policy since our site was in beta. (I might have stricter minimum quality standards, though ;-), because we are mature enough that many new questions can be answered with just a little research.)

It especially bothers me when I see an answered question with no upvotes, because it means the respondents are neglecting to vote for questions that nevertheless were good enough to answer.

Bear in mind that we are a kind of micro-economy in which reputation is the currency. Voting is like printing money: it's essentially free and creates the supply needed to reward people with bounties and visibility.

• Is that mico or micro? Apr 7 at 17:57
• @Nick Or maybe "myco," as in a mushroom-like economy? :-)
– whuber Mod
Apr 7 at 18:47
• The following search answers:1 score:0 closed:no duplicate:no shows that there are (as of april 7 2022) on this site 24,467 posts with at least one answer, and 0 (net) upvotes! Apr 7 at 22:19
• I confess every now and then I run across a question I answered, but did not upvote, and I am most often like "Huh?! What was I thinking?" In general I am sympathetic to your and Tim's takes. Apr 8 at 16:36
• Regarding It especially bothers me when I see an answered question with no upvotes..., I have a different view. I have answered a ton of questions that I think did not deserve an answer based on the quality of the question. I just felt like helping the person. Yet I cannot with good conscience upvote a question that hardly shows any effort and is riddled with typos. It is a bit like showing mercy to a criminal (for lack of a better example!) by not punishing them proportionately to how much harm they have caused. Mercy is not supposed to imply the crime was negligible. Apr 13 at 14:04
• @Richard Might I suggest improving the question -- either before or after answering it -- so that it does merit an upvote?
– whuber Mod
Apr 13 at 15:10
• @whuber, I do routinely fix typos, add relevant tags and improve titles. In some cases (under 50%) this does elevate the question to a level where it could be worthy of an upvote. I have been reluctant to upvote such questions as I view voting not only as a form of evaluation of the quality of the post but also as a form of attributing credit to the author. (I do not mind other users upvoting an edited post, though.) Perhaps I have been wrong about including the latter in my consideration. Apr 13 at 15:39
• @RichardHardy I understand your feelings. But after I answer a question, I reason there must have been something worthwhile to prompt that answer and so, despite any misgivings, I upvote the question. Almost all the time I have no regrets. The (very rare) exceptions are when the point of my answer is to explain why the question doesn't work.
– whuber Mod
Apr 13 at 16:41