numerical

How many recursions are made before every single root is found? Also, which ones are the roots? Here's my code: e=0.000001; f1=@(x) 14.*x.*exp(x-2)-12.*exp(x-2)-7.*x.^3+20.*x.^2-26.*x+12; a=0; c=3; while abs(c-a)>e b=(c+a)/2; if f1(a)*f1(b)<0 c=b; else a=b; end disp(b); end Bisection works by taking endpoints of some initial interval [a,b] and finding which half of the interval must contain the root (it evaluates the midpoint, and identifies which half has the sign change). Then bisection repeats the process on the identified half. Bisection converges upon only one possible root, and if your

I have this pandas dataframe from a query: | name | event | ---------------------------- | name_1 | event_1 | | name_1 | event_2 | | name_2 | event_1 | I need to convert the column event to numerical, or something to look like this: | name | event_1 | event_2 | ------------------------------- | name_1 | 1 | 0 | | name_1 | 0 | 1 | | name_2 | 1 | 0 | In the software rapidminer, i can do this with an operator "nominal to numerical", so i assume that in python convert the type of the column should be effective, but i can be mistaken. In the final, the idea is make a sum on the columns value with

I have a program in Perl that works with probabilities that can occasionally be very small. Because of rounding error, sometimes one of the probabilities comes out to be zero. I'd like to do a check for the following: use constant TINY_FLOAT => 1e-200; my $prob = calculate_prob(); if ( $prob == 0 ) { $prob = TINY_FLOAT; } This works fine, but I actually see Perl producing numbers that are smaller than 1e-200 (I just saw a 8.14e-314 fly by). For my application I can change calculate_prob() so that it returns the maximum of TINY_FLOAT and the actual probability, but this made me curious about

I am getting the following unexpected result when I do arithmetic with small numbers in Python: >>> sys.float_info sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1) >>> (1. - (1.e-17) ) < 1. False I know that floating point numbers do not have infinite precision, but it should be able to handle "large" small numbers like 1e-17, shouldn't it? wim >>> import numpy as np >>> np.nextafter(1., 0.) 0.99999999999999989 This is the next float after

I need to generate random numbers from Binomial(n,p) distribution. A Binomial(n,p) random variable is sum of n uniform variables which take 1 with probability p. In pseudo code, x=0; for(i=0; i<n; ++i) x+=(rand()<p?1:0); will generate a Binomial(n,p). I need to generate this for small as well as really large n, for example n = 10^6 and p=0.02. Is there any fast numerical algorithm to generate it? EDIT - Right now this is what I have as approximation (along with functions for exact Poisson and Normal distribution)- public long Binomial(long n, double p) { // As of now it is an approximation if

I've literally copied and pasted from the supplied source code for Numerical Recipes for C for in-place LU Matrix Decomposition, problem is its not working. I'm sure I'm doing something stupid but would appreciate anyone being able to point me in the right direction on this; I've been working on its all day and can't see what I'm doing wrong. POST-ANSWER UPDATE: The project is finished and working . Thanks to everyone for their guidance. #include <stdlib.h> #include <stdio.h> #include <math.h> #define MAT1 3 #define TINY 1e-20 int h_NR_LU_decomp(float *a, int *indx){ //Taken from Numerical