java Math类中的pow方法_百度知道
java Math类中的pow方法
.比如显示 Math.pow(64..求大神告诉我改如何解决啊..！！;3)是1而不是4..我用 这方法有点问题.,1&#47不知怎么
我有更好的答案
1&#47，x，他会先求出1/3的值，1/3中1和3均为int类型，所以值为0，所以自动转换为0.0，任何数字的0次幂都为1，所有这个地方求出来的值为1，而不是4，然后y这个值是浮点类型，y的值都是浮点类型的，而你现在要求的是pow(64.pow(x;3)，那么也就是64的1/3次方，如果我们口头上来算的话，可以看成64的3次方根，但是计算机不会这样算,y)这个函数是求x的y次方因为Math
采纳率：54%
那么结果为 1，并且第二个参数为正的有限奇数整数，或者 第一个参数为负无穷大，并且第二个参数为负的有限奇数整数，并且第二个参数为正无穷大，或者 第一个参数的绝对值小于 1。 如果 第一个参数的绝对值大于 1， 那么结果为正无穷大。 如果 第一个参数为负 0，并且第二个参数为负的有限奇数整数。 如果第一个参数为小于 0 的有限值， 如果第二个参数为有限的偶数整数。 如果 如果第一个参数为负 0，并且第二个参数为负无穷大， 那么结果为正无穷大.0。 如果 第一个参数的绝对值大于 1。 如果 如果第一个参数为负 0， 那么结果为负 0，并且结果恰好可以表示为一个 double 值，那么该结果恰好等于第一个参数的第二个参数次幂的算术结果。（在前面的描述中，那么结果等于第一个参数绝对值的第二个参数次幂的结果。 如果第二个参数为 1。 如果两个参数都为整数.0。 如果 第一个参数为负 0，并且第二个参数为负无穷大，或者 第一个参数的绝对值小于 1，那么结果为 NaN，那么结果与第一个参数相同。 如果第二个参数为 NaN，那么结果为 NaN。 如果第一个参数为 NaN，第二个参数非 0。 如果第二个参数为有限的奇数整数，那么结果等于负的第一个参数绝对值的第二个参数次幂的结果。 如果第二个参数为有限的非整数值，那么结果为 NaN，并且第二个参数为正无穷大， 那么结果为正 0。 如果第一个参数的绝对值等于1，并且第二个参数为无穷大，那么结果为 NaN。 如果 第一个参数为正 0，并且第二个参数大于 0，或者 第一个参数为正无穷大，并且第二个参数小于 0， 那么结果为正 0。 如果 第一个参数为正 0，并且第二个参数小于 0，或者 第一个参数为正无穷大，并且第二个参数大于 0， 那么结果为正无穷大，并且第二个参数大于 0 但不是有限的奇数整数，或者 第一个参数为负无穷大，并且第二个参数小于 0 但不是有限的奇数整数，或者 第一个参数为负无穷大， 那么结果为正 0，并且第二个参数为正的有限奇数整数， 那么结果为负无穷大，并且第二个参数小于 0 但不是有限的奇数整数，或者 第一个参数为负无穷大，并且第二个参数大于 0 但不是有限的奇数整数，当且仅当浮点数为有限值并且是方法 ceil 的定点数，或者是方法 floor 的定点数时，才可以认为浮点值是整数。当且仅当将某个单参数方法应用到某个值的结果等于该值时1/3计算机默认值是0，两个参数的值都应该是double 型返回第一个参数的第二个参数次幂的值。特殊情况如下： 如果第二个参数为正 0 或负 0
此题中变量参数是int型变量，而Math类下的pow（double a，double b）的，所以要吧Math.pow(64,1/3)换成Math.pow(64,1.0/3)1/3的结果=0因此只要把1或者3任意一个换成1.0
3.0即可变成double类型的淡然了都换也行，。。。
换了后是NaN啊...
“换了后是NaN啊...”这句是神吗意思？
比如算 -64 的三分之一次方是NaN
可能电脑把1/3看成0.3333了吧 这样算出来就是 非数字了把
问题出在1/3，因为1和3都是int类型，在java中直接运算1/3相当于运算(int)1/3=0,所以你的Math.pow(64,1/3)相当于Math.pow(64,0)，64的0次方，其结果就只能为1。
我们知道static double pow(double a, double b)
返回第一个参数的第二个参数次幂的值。可是这里的1/3计算机在计算时输出的结果为0，所以 Math.pow(64,1/3)就会等于1
大该是1/3是取整吧，等于0
其他4条回答
为您推荐：
其他类似问题
您可能关注的内容
math的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。随笔 - 88&
文章 - 0&评论 - 280&trackbacks - 0
1.&：数学对象，提供对数据的数学计算。如：获取绝对值、向上取整等。无构造函数，无法被初始化，只提供静态属性和方法。
2.& ：Js中提供数字的对象。包含整数、浮点数等等。并提供数字的类型转换、小数点截取等方法。
1. Math 对象
　　Math 对象，是数学对象，提供对数据的数学计算，如：获取绝对值、向上取整等。无构造函数，无法被初始化，只提供静态属性和方法。
1.2 构造函数
　　无 ：Math 对象无构造函数，无法被初始化，只提供静态属性和方法。
1.3 静态属性
1.3.1 Math.E ：常量e。返回自然对数的底数：2.045
1.3.2&Math.PI ：常量&。返回圆周率的值 ：3.793
1.4 静态方法
1.4.1 Math.sin(value) ：正弦函数1.4.2 Math.cos(value) ：余弦函数1.4.3 Math.tan(value) ：正切函数1.4.4 Math.asin(value) ：反正弦函数1.4.5 Math.acos(value) ：反余弦函数1.4.6 Math.atan(value) ：反正切函数
1.4.7&Math.abs(value) ：返回绝对值
①value {Number | NumberStr} ：数字或者纯数字的字符串。
{Number} 返回参数的绝对值数字。若参数不为数字，返回NaN。
Math.abs('123'); // =& 123 ：纯数字字符串
Math.abs('-123'); // =& 123
Math.abs(123); // =& 123
Math.abs(-123); // =& 123
Math.abs('123a'); // =& NaN ：非纯数字字符串
1.4.8 &Math.ceil(value) ： 对一个数向上取整，并不是四舍五入
①value&{Number | NumberStr} ：数字或者纯数字的字符串。
{Number} 返回取整后的值。若参数不为数字，返回NaN。
Math.ceil(2.7); // =& 3
Math.ceil(2.3); // =& 3 ：2.3 向上取整返回 3
Math.ceil(-2.7); // =& -2
Math.ceil(-2.3); // =& -2
Math.ceil('2.7'); // =& 3 ：纯数字字符串
Math.ceil('2.7a'); // =& NaN ：非纯数字字符串
1.4.9 Math.floor(value) ：对一个数向下取整，并不是四舍五入
①value&{Number | NumberStr} ：数字或者纯数字的字符串。
{Number} 返回取整后的值。若参数不为数字，返回NaN。
Math.floor(2.7); // =& 2
Math.floor(2.3); // =& 2
Math.floor(-2.7); // =& -3 ：-2.7 向下取整返回 -3
Math.floor(-2.3); // =& -3
Math.floor('2.7'); // =& 2 ：纯数字字符串
Math.floor('2.7a'); // =& NaN ：非纯数字字符串
1.4.10 Math.max(value1,value2...valueN) ：返回参数中最大的值
①value1,value2.....valueN&{Number | NumberStr} ：数字或者纯数字的字符串。
{Number} 返回最大值。若一个参数不为数字，返回NaN。
Math.max(1, 2, 3, 4, 5); // =& 5
Math.max(1, 2, 3, 4, '5' ); // =& 5
Math.max(1, 2, 3, 4, 'a'); // =& NaN
1.4.11 Math.min(value1,value2...valueN) ：返回参数中最小的值
①value1,value2.....valueN&{Number | NumberStr} ：数字或者纯数字的字符串。
{Number} 返回最大值。若一个参数不为数字，返回NaN。
Math.min(1, 2, 3, 4, 5); // =& 1
Math.min('1', 2, 3, 4, 5); // =& 1
Math.min(1, 2, 3, 4, 'a'); // =& NaN
1.4.12&Math.pow(x,y) ：返回x的y次方
①x&{Number | NumberStr} ：数字或者纯数字的字符串。
②y&{Number | NumberStr} ：数字或者纯数字的字符串。
{Number} 返回x的y次方。若一个参数不为数字，返回NaN。
Math.pow(2, 3); // =& 8 ：2的3次方
Math.pow(3, 2); // =& 9 ：3的2次方
Math.pow('4', 2); // =& 16 ：4的2次方
Math.pow('2a', 2); // =& NaN
1.4.13&Math.random() ：返回一个伪随机数,大于0，小于1.0
{Number}&返回一个伪随机数,大于0，小于1.0
Math.random(); // =& 0.3757
Math.random(); // =& 0.90415
Math.random(); // =& 0.56673
Math.random(); // =& 0.490746
1.4.14&Math.round(value) ： 四舍五入后取整
①value {Number | NumberStr} ：数字或者纯数字的字符串。
{Integer} 返回参数四舍五入后的整数。若参数不为数字，返回NaN。
Math.round(2.5); // =& 3
Math.round(2.4); // =& 2
Math.round(-2.6); // =& -3
Math.round(-2.5); // =& -2 ：-2.5四舍五入为 -2
Math.round(-2.4); // =& -2
Math.round('2.7'); // =& 3 ：纯数字字符串
Math.round('2.7a'); // =& NaN ：非纯数字字符串
1.4.15&Math.sqrt(value) ：返回参数的平方根
①value&{Number | NumberStr} ：数字或者纯数字的字符串
{Number}&返回参数的平方根
console.log( Math.sqrt(9) ); // =& 3
console.log( Math.sqrt(16) ); // =& 4
console.log( Math.sqrt('25') ); // =& 5
console.log( Math.sqrt('a') ); // =& NaN
2.&Number 对象
　　Number 对象，是数字对象，包含js中的整数、浮点数等等。
var a = 1;
var b = 1.1;
2.3 静态属性
2.3.1&Number.MAX_VALUE ：表示JS中最大的数字，约为 1.79e+308
2.3.2&Number.MIN_VALUE ：表示JS中最小的数字，约为 5e-324
2.3.3&Number.NaN ：返回NaN，表示非数字值，与任意其他数字不等，也包括NaN本身。应使用Number.isNaN() 来进行判断。
2.3.4&Number.NEGATIVE_INFINITY&：返回 -Infinity ，表示负无穷。
2.3.5&Number.POSITIVE_INFINITY &：返回&Infinity ，表示正无穷。进行计算的值大于Number.MAX_VALUE就返回&Infinity 。
2.4 静态方法
2.4.1 Number.isInteger(value) ：判断参数是否为整数&
①value&{Number} ：数字
{Boolean} 返回参数是否为整数&。纯整数的字符串也返回false。
Number.isInteger(1); // =& true
Number.isInteger(1.1); // =& false
Number.isInteger('1'); // =& false ：纯整数的字符串也返回false
Number.isInteger('1.1'); // =& false
Number.isInteger('a'); // =& false ：非字符串返回false
2.4.2&Number.isNaN(value) ：判断参数是否为NaN
①value&{Object} ：任意类型
{Boolean} 返回参数是否为NaN 。
Number.isNaN(NaN); // =& true
Number.isNaN('NaN'); // =& false :'NaN'字符串，并不为NaN
Number.isNaN(1); // =& false
Number.isNaN('1'); // =& false
2.4.3&Number.parseFloat(value) ：把参数转换为浮点数
①value&{Number | NumberStr} ：数字或者纯数字的字符串
{Integer&| Float} 返回整数或浮点数数值
Number.parseFloat(1); // =& 1 ：整数还是返回整数
Number.parseFloat(1.1); // =& 1.1
Number.parseFloat('1aaa'); // =& 1 ：字符串前面为数字的，只返回数字
Number.parseFloat('1.1aaa'); // =& 1.1
Number.parseFloat('a1'); // =& NaN ：非数字开头，返回NaN
Number.parseFloat('a'); // =& NaN
2.4.4&Number.parseInt(value) ：把参数转换为整数
①value&{Number | NumberStr} ：数字或者纯数字的字符串
{Integer} 返回整数数值
Number.parseInt(1); // =& 1
Number.parseInt(1.1); // =& 1 ：浮点数返回整数
Number.parseInt('1aaa'); // =& 1 ：字符串前面为数字的，只返回数字
Number.parseInt('1.1aaa'); // =& 1
Number.parseInt('a1'); // =& NaN ：非数字开头，返回NaN
Number.parseInt('a'); // =& NaN
2.5 实例方法
2.5.1&toExponential(value) ：将一个数字转为指数类型，参数表示小数点后的位数
①value&{Number} &：表示小数点后的位数
{String} 返回转换后的指数类型字符串
().toExponential(2); // =& 1.23e+8 ：小数点2位
().toExponential(5); // =& 1.23457e+8 ：小数点5位
().toExponential(10); // =& 1.e+8 ：小数点10位，不足位数用0补位
2.5.2&toFixed(value) ：将一个数字转换为指定小数位数的字符串。不传入参数，就是没小数位。返回值为四舍五入
①value&{Number} &：表示小数点后的位数
{String} 返回转换后的字符串；不够小数位以0填充；返回值为四舍五入后的值
console.log((1).toFixed(2)); // =& 1.00
console.log((1.2).toFixed(2)); // =& 1.20 ：不足位数，以0补位
console.log((1.277).toFixed(2)); // =& 1.28 ：进行了四舍五入
2.5.3&toString() ：使用指定的进制，将一个数字转换为字符串。不传入参数，默认为十进制。
①value&{Number} &：表示进制数，取值范围：2到36
{String} 转换后进制的字符串
(10).toString(); // =& 10 ：默认为十进制
(10).toString(2); // =& 1010 ：二进制
(10).toString(10); // =& 10 ：十进制
(10).toString(16); // =& a ：十六进制
2.6 应用场景
2.6.1 浮点数的加减乘除异常
说明：Js中的2个浮点数进行加减乘除运算，会返回异常的数值，如：0.2+0.7，返回0.。可以使用toFixed()方法，指定小数位。
console.log(0.2 + 0.7); // =& 0.9999
console.log(0.7 - 0.5); // =& 0.99996
console.log(3.03 * 10); // =& 30.997
// 使用toFixed()方法
console.log( (0.2 + 0.7).toFixed(2) ); // =& 0.90
console.log( (0.7 - 0.5).toFixed(2) ); // =& 0.20
console.log( (3.03 * 10).toFixed(2) ); // =& 30.30
2.6.2 减法运算
说明：Js中进行减法运算时，会先把前后的值转换为数值再进行运算。若转换失败，返回NaN。
console.log('1' - 0); // =& 1 ：纯数字字符串减去0，可以快速转换为Nubmer对象
console.log( ('1' - 0).toFixed(2) ); // =& 1.00 ：快速转换为Nubmer对象后调用实例方法
console.log('1' - 'a'); // =& NaN ：一方无法转换为Nubmer对象
菜单加载中...
阅读(...) 评论()Java中求平方以及立方的函数式什么？_百度知道
Java中求平方以及立方的函数式什么？
Java中求平方以及立方的函数式什么？还有找到Math.java源代码 怎么用啊？打开后都是乱码也看不懂
我有更好的答案
平方根：开平方用math.sqrt(double n);就可以了，n就是要被开方的数扩展下，如果要给m开n次方就用java.lang.StrictMath.pow(m,1.0/n);因为都是用的double类型的数字，所以会有误差，比如m＝64；n＝3，y＝java.lang.StrictMath.pow(m,1.0/n);这样如果System.out.println(y); y就是3.9996Math.pow(x,3)就是立方
jdk安装目录下的src.zip里就是源码，很多方法是用本地方法去实现的。如果是一般的数，直接两个变量相乘就可以了吧。我也很少用math，找了一下，Math.pow(x,2)就是平方，但看到源码应该也没多大帮助
本回答被提问者采纳
返回参数a 的参数b 次幂的值。用法这个函数试一下吧
pow(double a：System.out.println(Math.pow(2,3))
谢谢 能告诉我怎么在Math.java里查函数吗
在JDK安装文件里找到的Math.java怎么用？
你是要查函数的用法吗，如果要查函数用法，通过JDK在线的帮助文档就可以。
Math.sqrt()和Math.cbrt()希望楼主采纳！
x * x 立方
java中通常进行数学运算的东西都在Math类中，例如你这个就是 Math类中的pow方法，是个静态方法，你直接用类名调用就行，比如求5的6次幂，那就是Math.pow(5,6),其他的数学方法可以参考一下。数学函数都在Math类中，求平方根用Math.sqrt(double a) 求立方根用Math.cbrt(double a) 求其他的方根可以用Math.pow(double a, double b)。源码如下，import java.util.S class { public static void main(String[] args) { System.out.println(&请按小到大输入两个整数：&); Scanner ner=new Scanner(System.in); int a=ner.nextInt(); int b=ner.nextInt(); for(int i=a;i)
Math.pow(x, y)
其他4条回答
为您推荐：
其他类似问题
您可能关注的内容
java的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。javascript - Why is Math.pow(0, 0) === 1? - Stack Overflow
Join Stack Overflow to learn, share knowledge, and build your career.
or sign in with
We all know that 00 is indeterminate.
But, javascript says that:
Math.pow(0, 0) === 1 // true
and C++ says the same thing:
pow(0, 0) == 1 // true
I know that:
&Math.pow(0.001, 0.001)
But why does Math.pow(0, 0) throw no errors? Or maybe a NaN would be better than 1.
69.5k989131
49.7k47167309
the result is basically implementation defined behavior since mathematically we have a contradictory situation where N^0 should always be 1 but 0^N should always be 0 for N & 0, so you should have no expectations mathematically as to the result of this either. This
forum posts goes into a bit more details.
Although having pow(0,0) result in 1 is useful for many applications as the
states in the section covering IEC 60559 floating-point arithmetic support:
Generally, C99 eschews a NaN result where a numerical value is useful. [...] The results of pow(∞,0) and pow(0,0) are both 1, because there are applications that can exploit this definition. For example, if x(p) and y(p) are any analytic functions that become zero at p = a, then pow(x,y), which equals exp(y*log(x)), approaches 1 as p approaches a.
Update C++
As leemes correctly pointed out I originally linked to the reference for the complex version of pow while the
version claims it is domain error the
falls back to the
and both C99 and C11 in section 7.12.7.4 The pow functions paragraph 2 says (emphasis mine):
[...]A domain error may occur if x is zero and y is zero.[...]
which as far as I can tell means this behavior is
Winding back a bit section 7.12.1 Treatment of error conditions says:
[...]a domain error occurs if an input argument is outside the domain over
which the mathematical function is defined.[...] On a domain error, the function returns an implementation- if the integer expression math_errhandling & MATH_ERRNO is nonzero, the integer expression errno acquires the value EDOM; [...]
So if there was a domain error then this would be implementation defined behavior but in both the latest versions of gcc and clang the value of errno is 0 so it is not a domain error for those compilers.
Update Javascript
For Javascript the
in section 15.8 The Math Object under 15.8.2.13 pow (x, y) says amongst other conditions that:
If y is +0, the result is 1, even if x is NaN.
113k20274434
If y is NaN, the result is NaN.
If y is +0, the result is 1, even if x is NaN.
If y is -0, the result is 1, even if x is NaN.
If x is NaN and y is nonzero, the result is NaN.
If abs(x)>1 and y is +∞, the result is +∞.
If abs(x)>1 and y is -∞, the result is +0.
If abs(x)==1 and y is +∞, the result is NaN.
If abs(x)==1 and y is -∞, the result is NaN.
If abs(x)&1 and y is +∞, the result is +0.
If abs(x)&1 and y is -∞, the result is +∞.
If x is +∞ and y>0, the result is +∞.
If x is +∞ and y&0, the result is +0.
If x is -∞ and y>0 and y is an odd integer, the result is -∞.
If x is -∞ and y>0 and y is not an odd integer, the result is +∞.
If x is -∞ and y&0 and y is an odd integer, the result is -0.
If x is -∞ and y&0 and y is not an odd integer, the result is +0.
If x is +0 and y>0, the result is +0.
If x is +0 and y&0, the result is +∞.
If x is -0 and y>0 and y is an odd integer, the result is -0.
If x is -0 and y>0 and y is not an odd integer, the result is +0.
If x is -0 and y&0 and y is an odd integer, the result is -∞.
If x is -0 and y&0 and y is not an odd integer, the result is +∞.
If x&0 and x is finite and y is finite and y is not an integer, the result is NaN.
emphasis mine
as a general rule, native functions to any language should work as described in the language specification. Sometimes this includes explicitly "undefined behavior" where it's up to the implementer to determine what the result should be, however this is not a case of undefined behavior.
119k27245292
It is just convention to define it as 1, 0 or to leave it undefined. The definition
is wide spread because of the following definition:
ECMA-Script documentation says the following about pow(x,y):
If y is +0, the result is 1, even if x is NaN.
If y is -0, the result is 1, even if x is NaN.
3,82032836
According to Wikipedia:
In most settings not involving continuity in the exponent, interpreting 00 as 1 simplifies formulas and eliminates the need for special cases in theorems.
There are several possible ways to treat 0**0 with pros and cons to each (see
for an extended discussion).
floating point standard recommends three different functions:
pow treats 0**0 as 1. This is the oldest defined version. If the power is an exact integer the result is the same as for pown, otherwise the result is as for powr (except for some exceptional cases).
pown treats 0**0 as 1. The power must be an exact integer. The value is define e.g., pown(-3,5) is -243.
powr treats 0**0 as NaN (Not-a-Number – undefined). The value is also NaN for cases like powr(-3,2) where the base is less than zero. The value is defined by exp(power'×log(base)).
314k50671834
Donald Knuth
sort of settled this debate in 1992 with the following:
And went even more into details in his paper .
Basically, while we don't have 1 as the limit of f(x)/g(x) for all not all functions f(x) and g(x), it still makes combinatorics so much simpler to define 0^0=1, and then just make special cases in the few places where you need to consider functions such as 0^x, which are weird anyway. After all x^0 comes up a lot more often.
Some of the best discussions I know of this topic (other than the Knuth paper) are:
19.8k166195
When you want to know what value you should give to f(a) when f isn't directly computable in a, you compute the limit of f when x tends towards a.
In case of x^y, usual limits tend towards 1 when x and y tend to 0, and especially x^x tends towards 1 when x tends to 0.
253k46529554
The C language definition says (7.12.7.4/2):
A domain error may occur if x is zero and y is zero.
It also says (7.12.1/2):
On a domain error, the function returns an implementation- if the integer expression math_errhandling & MATH_ERRNO is nonzero, the integer expression errno acquires the value EDOM; if the integer expression math_errhandling & MATH_ERREXCEPT is nonzero, the ‘‘invalid’’ floating-point exception is raised.
By default, the value of math_errhandling is MATH_ERRNO, so check errno for the value EDOM.
51.1k335100
I'd like to disagree with some of the previous answers' assertion that it's a matter of convention or convenience (covering some special cases for various theorems, etc) that 0^0 be defined as 1 instead of 0.
Exponentiation doesn't actually fit that well with our other mathematical notations, so the definition we all learn leaves room for confusion. A slightly different way of approaching it is to say that a^b (or exp(a, b), if you like) returns the value multiplicatively equivalent to multiplying some other thing by a, repeated b times.
When we multiply 5 by 4, 2 times, we get 80. We've multiplied 5 by 16. So 4^2 = 16.
When you multiply 14 by 0, 0 times, we are left with 14. We've multiplied it 1. Hence, 0^0 = 1.
This line of thinking might also help to clarify negative and fractional exponents. 4^(-2) is a 16th, because 'negative multiplication' is division - we divide by four twice.
a^(1/2) is root(a), because multiplying something by the root of a is half the multiplicative work as multiplying it by a itself - you would have to do it twice to multiply something by 4 = 4^1 = (4^(1/2))^2
For this to understand you need to solve calculus:
Expanding x^x around zero using Taylor series, we get:
So to understand what's going on with limit when x goes to zero,
we need to find out what's going on with second term x log(x), because other terms are proportional to x log(x) raised to some power.
We need to use transformation:
Now after this transformation we can use , which states that:
So differentiating that transformation we get:
So we've calculated that term log(x)*x approaches 0 when x approaches 0.
It's easy to see that other consecutive terms also approaches zero and even faster than second term.
So at point x=0, series becomes 1 + 0 + 0 + 0 + ... and thus equals to 1.
6,35043356
protected by
Thank you for your interest in this question.
Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10
on this site (the ).
Would you like to answer one of these
Not the answer you're looking for?
Browse other questions tagged
Upcoming Events
ends Mar 27
Stack Overflow works best with JavaScript enabled}