arithmetic in a Makefile
arithmetic in a Makefile Is it possible to perform some operations on variables in a Makefile. For instance, defining JPI=4 JPJ=2 Is it possible to define in the same Makefile a variable JPIJ equal to the expanded value of $(JPI)*$(JPJ) ? If you're using GNU make and have bc installed on your system, you can use something like this: JPI=4 JPJ=2 FOO=$(shell echo $(JPI)\*$(JPJ) | bc) all: echo $(FOO) It's clumsy (or brilliant, depending on your perspective), but you can do arithmetic directly in GNU make. See Learning GNU Make Functions with Arithmetic. Be aware though that this method doesn't scale well. It will work wonderfully for small numbers as you have shown in your question, but it doesn't do well when you're working with numbers with a large magnitude (greater than 10,000,000

Arithmetic + and Bitwise OR
Arithmetic + and Bitwise OR Is there any difference between Arithmetic + and bitwise OR. In what way this is differing. uint a = 10; uint b = 20; uint arithmeticresult = a + b; uint bitwiseOR = a | b; Both the results are 30. Edit : Small changes to hide my stupidity. Counterexample: 2 + 2...) (1+1=2) 00000010 OR 00000010 Result 00000010 VS 00000010 + 00000010 Result 00000100 Bitwise OR goes through every bit of two digits and applies the following truth table: A B | A|B 0 0 | 0 0 1 | 1 1 0 | 1 1 1 | 1 Meanwhile the arithmetic + operator actually..., or the bit is set in B but not A. In that case the arithmetic + and the bit-wise or would produce the same result... as would the bitwise xor for that matter. Try setting a = 230 and b = 120. And you'll observer the difference in results. The reason is very simple. In the arithmentic addition

Modular arithmetic
Modular arithmetic I'm new to cryptography and modular arithmetic. So, I'm sure it's a silly question, but I can't help it. How do I calculate a from      pow(a,q) = 1 (mod p), where p and q are known? I don't get the "1 (mod p)" part, it equals to 1, doesn't it? If so, than... from a programming perspective, another way of saying it is that pow(a,q)%p=1, where "%" is the "remainder" operator as implemented in several languages (assuming that p>1). You should read the Wikipedia article on Modular arithmetic, or any elementary number theory book (or even a cryptography book, since it is likely to introduce modular arithmetic). To answer your other question: there is no general formula for finding such an a (to the best of my knowledge) in general. Assuming that p is prime, and using Fermat's little theorem to reduce q modulo p-1, and assuming that q divides p-1

Pointer Arithmetic
Pointer Arithmetic Does anyone have any good articles or explanations (blogs, examples) for pointer arithmetic? Figure the audience is a bunch of Java programmers learning C and C++. First, the binky video may help. It's a nice video about pointers. For arithmetic, here is an example: int * pa... the generic typedef ptrdiff_t. Here is where I learned pointers: http://www.cplusplus.com/doc/tutorial/pointers.html Once you understand pointers, pointer arithmetic is easy. The only difference between it and regular arithmetic is that the number you are adding to the pointer will be multiplied by the size of the type that the pointer is pointing to. For example, if you have a pointer to an int and an int's size is 4 bytes, (pointer_to_int + 4) will evaluate to a memory address 16 bytes (4 ints) ahead. So when you write (a_pointer + a_number) in pointer arithmetic, what's really

Arithmetic in ruby
Arithmetic in ruby Why this code 7.30 - 7.20 in ruby returns 0.0999999999999996, not 0.10? But if i'll write 7.30 - 7.16, for example, everything will be ok, i'll get 0.14. What the problem, and how can i solve it? That is a common error from how float point numbers are represented in memory...-in-floating-point-numbers What Every Computer Scientist Should Know About Floating-Point Arithmetic The problem is that some numbers we can easily write in decimal don't have an exact representation in the particular floating point format implemented by current hardware. A casual way of stating... of people don't even realize that JS does everything in floating point. Use fixed point arithmetic. Ruby actually makes this really easy; it's one of the only languages that seamlessly shifts to Class Bignum from Fixnum as numbers get bigger. Use a class that is designed to solve this problem, like

Pointer arithmetic.
Pointer arithmetic. Having code: int** a = new int*[2]; a[0] = new int(1); a[1] = new int(2); cout << "a[0] " << a[0] << '\n'; cout << "a[1] " << a[1] << '\n'; cout << "a[2] " << a[2] << '\n'; cout << "a[0] + 1 " << a[0] + 1 << '\n';//WHY THIS ISN'T == a[1] ? cout << "*(a + 1): " << *(a + 1) << '\n'; //WHY THIS IS == a[1] ? cout << "a[0] - a[1] " << static_cast<int>(a[0] - a[1])<< '\n';//WHY THIS IS == 16 not 4? cout << sizeof(int**); Questions are included right next to relevant lines in code. a[0] and a[1] are contiguous, and they are both pointers, but they do not point to contiguous areas of memory. That's because the memory pointers returned by the new operator are effectively unpredictable. In other words, there is no guarantee (in fact quite opposite

bash: $[] vs. $(())
bash: $[] vs. $(()) I have just stumbled upon the bash syntax: foo=42 bar=$[foo+1] # evaluates an arithmetic expression When I Googled for this, I found http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_03_04.html#sect_03_04_05: 3.4.6. Arithmetic expansion Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. The format for arithmetic expansion is: $(( EXPRESSION )) ... Wherever possible, Bash users should try to use the syntax with square brackets: $[ EXPRESSION ] However, this will only calculate the result of EXPRESSION, and do no tests... In my bash man page I can only find the $(( EXPRESSION )) form such as: foo=42 bar=$((foo+1)) # evaluates an arithmetic expression So what tests are not performed with $[...] that do with $((...)), or is the $[...] just a legacy version

Question on Pointer Arithmetic
Question on Pointer Arithmetic Heyy Everybody! I am trying to create a memory management system, so that a user can call myMalloc, a method I created. I have a linked list keeping track of my free memory. My problem is when I am attempting to find the end of a free bit in my linked list. I am... of that segment. However, I keep getting the warning: "pointer of type 'void*' used in arithmetic" Is there a better way of doing this? Thanks! Pointer arithmetic uses the size of the underlying type. If int is 4 bytes: int *p = some_address; p++; will increment p by 4 bytes. void can't be used in pointer arithmetic because void has no size associated with. If you want to do byte-sized arithmetic on void pointers, you need to cast the pointers to a byte-sized type. int *tailEnd = ( int* ) ( previousPlace->head_ptr + ((previousPlace->size+1)*(sizeof(int

Fixed-point arithmetic
Fixed-point arithmetic Does anyone know of a library to do fixed point arithmetic in Python? Or, does anyone has sample code? If you are interested in doing fixed point arithmetic, the Python Standard Library has a decimal module that can do it. Actually, it has a more flexible floating point ability than the built-in too. By flexible I mean that it: Has "signals" for various exceptional conditions (these can be set to do a variety of things on signaling) Has positive and negative infinities, as well as NaN (not a number) Can differentiate between positive and negative 0 Allows you to set different rounding schemes. Allows you to set your own min and max values. All in all, it is handy for a million household uses

Java floating point arithmetic
Java floating point arithmetic Hello I need to do some floating point arithmetic in java as shown in the code below: public class TestMain { private static Map<Integer, Double> ccc = new HashMap<Integer, Double>() { { put(1, 0.01); put(2, 0.02); put(3, 0.05... of values outputed by the Betfair spinner widget... http://help.betfair.com/contents/itemId/i65767327/index.en.html Floating point arithmetic in Java seems to introduce some unexpected errors. For example, I get 2.180000000000001 instead of 2.18 Anybody know how I can get round this issue. What use are floating point numbers is you can't trust the results of arithmetic performed on them? Thanks Floating-point numbers are imprecise, especially since they work in binary fractions (1/2, 1/4, 1/8, 1/16, 1/32, ...) instead of decimal fractions (1/10, 1/100, 1/1000, ...). Just define what you feel

Arithmetic with pointer types/
Arithmetic with pointer types/ Some examples of adding and subtracting similarly typed pointers, using numeric and character pointers please. Using C. Thanks. You can check this to know about pointer arithmetic Here's a practical example which extracts a single character from a C string: char charAt( char *str, size_t idx) { if (idx > strlen (str)) return '\0'; return *(str+idx); } Or another, which swaps an integer in an array with the one immediately before it (with no range checking): void swapInts( int *base, size_t idx) { tmp = *(base+idx); *(base+idx) = *(base+idx-1); *(base+idx-1) = tmp; } In both these cases, *(pointer+offset) is identical to pointer[offfset] but using pointer arithmetic instead of array offsets: *(str+idx) -> str[idx] *(base+idx) -> base[idx] *(base+idx-1] -> base[idx-1] Warning

BASH Arithmetic Expressions
BASH Arithmetic Expressions I had used several ways to do some simple integer arithmetic in BASH (3.2). But I can't figure out the best (preferred) way to do it. result=`expr 1 + 2` result=$(( 1 + 2 )) let "result = 1 + 2" What are the fundamental differences between those expressions? Is there other ways to do the same? Is the use of a tool like bc mandatory for floating point arithmetic? result=`echo "7/354" | bc` I can't say it's "mandatory" but bc is probably your best bet for general purpose arithmetic. For something fancier, you can always pipe through Perl. The downside...} # result: 4 Edit: The $(()) construct is called "arithmetic expansion" and causes the contents to be evaluated as an integer expression. It's a syntax element of the shell. If a variable is declared as an integer you don't need to use either form of double parentheses, you can omit the dollar sign

Date arithmetic in Java
Date arithmetic in Java My program is about generating (producing) a Kurosawa and making the customers produce it. Every time we generate a Kurosawa, we have to print its id, its production date and expiration date, which is 3 months from the production date. My problem is: How can I calculate the date after 3 months? Thank you. I believe that the Java Calendar Library should help you. Use the built-in Java Calendar API. Calendar c = Calendar.getInstance(); c.add(Calendar.MONTH, 3); Refer to the API for exactly how to print out the date, in the format you are looking for. You could also... API. If you need to work with date arithmetic JODA works better, as Calendar likes timestamps

Matrix arithmetic in PHP again
Matrix arithmetic in PHP again Hi, I recently asked a question about matrix libraries in PHP. I went with the suggestion of using the Math_Matrix PEAR library. However, it turns out that this library is out of date (meaning I had to change some of the code in the library to make it work with my version of PHP), and it doesn't really do what I need (e.g., it won't let you transpose a non-square matrix, for some reason). I wonder if anyone has any experience of working with matrices in PHP, and if they can recommend a library that they consider to be workable. Thanks, Ben

Overloading Arithmetic Operators
Overloading Arithmetic Operators The assignment operator can be declared as T& operator= (const t&); in a class, but the arithmetic operators cannot be defined that way. It has to be friend function. I don't understand why? Can you please explain ? They ideally should be globals and not necessarily friends, so that you can write: yourtype v = 1; yourtype w = 1 + v; Since, 1 is not an object of yourtype, if the operator+ were a member it would throw a fit. However, making it global makes it convert the 1 to yourtype and then perform the operation. Making it a friend helps to extract and manipulate the members of yourtype as required -- though not required. As an example: You can implement the member function operator+= and use it in the implementation of the operator+. I think that C++ FAQ Lite will give you a definitive answer. It is not mandatory that arithmetic operators