deterministic

I'm using QueryPerformanceCounter to do some timing in my application. However, after running it for a few days the application seems to stop functioning properly. If I simply restart the application it starts working again. This makes me a believe I have an overflow problem in my timing code. // Author: Ryan M. Geiss // http://www.geisswerks.com/ryan/FAQS/timing.html class timer { public: timer() { QueryPerformanceFrequency(&freq_); QueryPerformanceCounter(&time_); } void tick(double interval) { LARGE_INTEGER t; QueryPerformanceCounter(&t); if (time_.QuadPart != 0) { int ticks_to_wait =

How can I code member/2 that has determinism for the last element. Currently I am using: member(X,[X|_]). member(X,[_|Y]) :- member(X,Y). When I query the following: ?- member(X,[1,2]). X = 1 ; X = 2 ; No The interpreter continues searching after returning 2 since there is still a choice point left. How could I implement member/2 so that this does not happen anymore? But the full semantic of member/2 should be preserved, i.e. answers such as: ?- member(X,Y) Y = [X|_1] ; Y = [_1,X|_2] ; etc.. Should still work as befor. Bye member(B, [C|A]) :- member_(A, B, C). member_(_, A, A). member_([C|A],

Now I have a really tricky thing with Oracle execution plans running havoc, when I use a DETERMINISTIC function on the right hand side of the LIKE operator. This is my situation: The Situation I thought it to be wise to execute a query like this (simplified): SELECT [...] FROM customers cust JOIN addresses addr ON addr.cust_id = cust.id WHERE special_char_filter(cust.surname) like special_char_filter(?) And I would bind ? to something like 'Eder%' . Now customers and addresses are very large tables. That's why it's important to use indexes. Of course, there is a regular index on addresses.cust

I got confused with a seemingly simple concept. Mysql defines deterministic function as a function that always produces the same result for the same input parameters So in my understanding, functions like CREATE FUNCTION foo (val INT) READS SQL DATA BEGIN DECLARE retval INT; SET retval = (SELECT COUNT(*) FROM table_1 WHERE field_1 = val); RETURN retval; END; are not deterministic (there is no guarantee that delete/update/insert does not happen between 2 calls to the function). At the same time, I saw many functions which do pretty much the same, i.e. return value based on result of queries,

So from what I understand about deterministic predicates: Deterministic predicate = 1 solution Non-deterministic predicate = multiple solutions Are there any type of rules as to how you can detect if the predicate is one or the other? Like looking at the search tree, etc. There is no clear, generally accepted consensus about these notions. However, they are usually based rather on the observed answers and not based on the number of solutions. In certain contexts the notions are very implementation related. Non-determinate may mean: leaves a choice point open. And sometimes determinate means:

This is my first question on this site, and I only have a basic mathematical understanding of RSA, so please bear with me! :) I'm writing a Java web application for my final year project at university. It's a web-based implementation of "Pret-a-voter", a secure voting system, for those who have heard of it. Essentially my problem is that I want to be able to give someone performing the role of an auditor: a source byte array (the plaintext to be encrypted) an RSA public key file a " destination " byte array, which is the result of my own computation of the cipherdata given the plaintext and

Having already read this question I'm reasonably certain that a given process using floating point arithmatic with the same input (on the same hardware, compiled with the same compiler) should be deterministic. I'm looking at a case where this isn't true and trying to determine what could have caused this. I've compiled an executable and I'm feeding it the exact same data, running on a single machine (non-multithreaded) but I'm getting errors of about 3.814697265625e-06 which after careful googling I found is actually equal to 1/4^9 = 1/2^18 = 1/262144. which is pretty close to the precision