similar to: ifultools on ppc debian

Dear all, What is the usage of the ".Call()"? What is the meaning of the follows: S=.Call("RS_fractal_spectral_density_function_direct",x,as.vector(taper.),as.logical(center),as.logical(recenter),TRUE,as.integer(npad),COPY=rep(FALSE,6),CLASSES=c(rep("matrix",2),rep("logical",3),"integer"),PACKAGE="ifultools") And is a function

But it is not taken 'verbatim from src/main/print.c' (at least not in that version of R), and the code is not run with USE_RINTERNALS defined when write-barrier checking is enabled. The example has been updated to match the current code in 2.7.0 alpha. On Sun, 30 Mar 2008, sanders at fs.tum.de wrote: > Full_Name: Simon Anders > Version: 2.6.2 > OS: Ubuntu Linux >

Dear Prof Ripley, Prof Brian Ripley wrote: > But it is not taken 'verbatim from src/main/print.c' (at least not in > that version of R), and the code is not run with USE_RINTERNALS defined > when write-barrier checking is enabled. > > The example has been updated to match the current code in 2.7.0 alpha. I just assumed that it is copied verbatim without checking because

Hi, Somehow function-like macros from Rinternals.h are not defined when I include the file. foo.c ################## #include <R.h> #include <Rinternals.h> #ifndef NILSXP #error("NILSXP") #endif #ifndef INTEGER #error("INTEGER") #endif ################### When compiled: vor/src% gcc -I/usr/local/lib/R/include -g -O2 -c foo.c -o foo.o foo.c:11:2: #error

Hi all, it seems that from R 4.0.1 EXTPTR_PTR can be either a macro or a function, depending on whether USE_RINTERNALS is requested. Jeroen helped me find that this was in 78592: https://github.com/wch/r-source/commit/c634fec5214e73747b44d7c0e6f047fefe44667d This is a problem, because binary packages that are built on R 4.0.1 or R 4.0.2 will potentially not load on R 4.0.0, if they use the

I'm saying at the IR level, not the C level. IR makes certain assumptions about the representation of floating point numbers. Nothing to do with C, I only used it as an example. - CL > On Apr 14, 2016, at 4:49 PM, Martin J. O'Riordan <martin.oriordan at movidius.com> wrote: > > I don't think that this is correct. > > | Let's say we have an int x, and we

My understanding is that this checks whether the bit width of the integer *type* fits in the bit width of the mantissa, not the bit width of the integer value. - CL > On Apr 14, 2016, at 6:02 PM, escha at apple.com wrote: > > We already do this to some extent; see this code in InstCombineCasts: > > // fpto{s/u}i({u/s}itofp(X)) --> X or zext(X) or sext(X) or trunc(X) > //

I noticed some odd behavior with APFloat's convertFromString method. 1. If I pass the hex representation of the closest value to 0.1 (0x19999Ap-24), everything is fine and opOk is returned. However, if I pass the same value as a decimal string (0.10000002384185791015625), opInexact is set. 2. On the lower end of the scale, the smallest denormal 0x1p-149 returns opOk, but the

Hi all: I need an instruction that can convert decimal values into floating point numbers. i.e. say I have a decimal number 1110794174 (== 42355FBE in hex ) and (== 45.3435 as a float) essentially the mantissa and exponent representation needs to be used. Is there any way of doing this in llvm? Thanks and Regards -- -- Aparna Kotha Graduate Student Electrical and Computer Engineering

> Two of those are compile errors, suggesting you aren't pulling in the > right header file (it's in common/serialise-double.h I believe). Thanks, fixed those errors. > I can't tell for sure without seeing the diff. You may mean just > `ptr++`? But it could be something else, depending on what you're > trying to do. I'm trying to unserialise normalization

I'm trying to run e2fsck on a ~6TB filesystem which is about 90% full. We're doing backup to disk to this filesystem, and have a number of hard links (link counts up to 90). strace shows: write(1, "Pass 2: Checking ", 17) = 17 write(1, "directory", 9) = 9 write(1, " structure\n", 11) = 11 mmap(NULL, 91574272,

I have problem with integer overflow that I cannot understand. I have a character vector curr.lemmas with the following properties: length(curr.lemmas) # 61224 length(unique(curr.lemmas)) # 2652 That vector is the input to the following function: yules.k1 <- function(input) { m1 <- length(input); temp <- table(table(input)) m2 <- sum("*"(temp,

Hi all, I need to convert a floating point value from Microsoft Basic format to IEEE format. There's a simple way to achieve this in R or I have to write my own function? (e.g. convert the C code below) thanks t #include <string.h> /* for strncpy */ int _fmsbintoieee(float *src4, float *dest4) { unsigned char *msbin = (unsigned char *)src4; unsigned char *ieee

Hi all, I'd like to make use of some specific x86 Streaming SIMD Extension instructions, but I don't know where to start. For instance the 'rcpps' instructions computes a low precision but fast reciprocal. I've noticed that LLVM supports intrinsics, but I couldn't find any information on how to use them. I've tried digging through the LLVM-GCC code but it's just

a) Numeric values may be either integers (signed 32 bit) or double precision (53 bit mantissa). b) Double precision constants are numeric with no decoration (e.g. 61224). Integer constants have an L (e.g. 61224L). c) 61224*61224 > 2^31-1 so that answer cannot fit into an integer. d) Exponentiation is a floating point operation so the result of 61224L^2L is a floating point answer that CAN

Full_Name: Morten Welinder Version: snapshot OS: Submission from: (NULL) (65.213.85.129) Two things are wrong. 1. There is nan test outside IEEE_754. 2. The meat part of the function should really be something like... if (!lower_tail) x = -x; if (fabs (x) > 1) { double temp = atan (1 / x) / M_PI; return (x > 0) ? R_D_Clog (temp) : R_D_val (-temp); } else

Le 3 juin 2010 à 16:00, Martin Guy a écrit : > [off list] > >> 0.8f get converted in 0x3FE99999A0000000 by LLVM > > single precision > >> http://babbage.cs.qc.edu/IEEE-754/Decimal.html gives: >> >> 0x3FE999999999999A instead and this value cannot be read back by "llc"... > > double precision > > M Well For float 0.8 :

How precise is R numerically? For example I wrote the following function for calculating the volume of the ball inscribed in the unit cube in m dimensions. In order to see what happens in 40 dimensions, I created an output of 24 digits. But how many are precise? Thanks Josef Eschgf?ller Ferrara --------------------------------------- Vol = function (m) {if (m<=1) 1 else Vol(m-2)*pi/(m+m)}

We have a problem inverting a matrix which has the following eigenvalues: > eigen(tcross, only.values=TRUE) $values [1] 7.917775e+20 2.130980e+16 7.961620e+13 8.241041e+12 2.258325e+12 [6] 3.869428e+11 6.791041e+10 2.485352e+09 9.863098e+08 9.819373e+05 [11] 3.263408e+05 2.929853e+05 2.920419e+05 2.714355e+05 8.733435e+04 [16] 8.127136e+04 6.543883e+04 5.335074e+04

Before responding to Jeff's posting, let me reiterate my question: Why does a function using m1*m1 produce an integer overflow, but m1^2 does not? As for Jeff's 'response': > a) Numeric values may be either integers (signed 32 bit) or double precision (53 bit mantissa). > b) Double precision constants are numeric with no decoration (e.g. 61224). Integer constants have an L