/* largest_prime_factor_all_tests
*
*/
int largest_prime_factor_all_tests(void) {
/* local variables */
int tests_passed;
int expected;
int result;
tests_passed = 0;
/* test 1 */
expected = 29;
result = largest_prime_factor(13195);
if (result != expected) {
printf("%s\n", "Test 1 Failed!");
printf("%s%d%s%d\n", "Expected: ", expected, ". Result: ", result);
} else {
tests_passed++;
}
/* test 2 */
expected = 6857;
result = largest_prime_factor(600851475143);
if (result != expected) {
printf("%s\n", "Test 2 Failed!");
printf("%s%d%s%d\n", "Expected: ", expected, ". Result: ", result);
} else {
tests_passed++;
}
/* test 3 */
expected =167;
result = largest_prime_factor(334);
if (result != expected) {
printf("%s\n", "Test 3 Failed!");
printf("%s%d%s%d\n", "Expected: ", expected, ". Result: ", result);
} else {
tests_passed++;
}
/* test 4 */
expected = 7;
result = largest_prime_factor(5040);
if (result != expected) {
printf("%s\n", "Test 4 Failed!");
printf("%s%d%s%d\n", "Expected: ", expected, ". Result: ", result);
} else {
tests_passed++;
}
return tests_passed;
}
void benchmark_function() {
float start_time = (float)clock()/CLOCKS_PER_SEC;
int i;
int prime;
for(i = 0; i<100000; i++) {
prime = largest_prime_factor(600851475143);
}
prime = largest_prime_factor(600851475143);
float end_time = (float)clock()/CLOCKS_PER_SEC;
printf("Benchmark: %f\n", end_time - start_time);
}
int _tmain(int argc, _TCHAR* argv[])
{
assert(true == is_prime(2));
assert(true == is_prime(5));
assert(false == is_prime(4));
assert(true == is_prime(13));
assert(true == is_prime(29));
assert(true == is_prime(71));
assert(29 == largest_prime_factor(13195));
std::cout << "Largest prime factor: " << largest_prime_factor(600851475143) << std::endl;
return 0;
}
int main()
{
std::cout << largest_prime_factor(600851475143) << std::endl;
}
int main(int argc, char *argv[]) {
benchmark_function();
benchmark_function();
benchmark_function();
printf("Largest prime factor of 600851475143: %d\n", largest_prime_factor(600851475143));
}
int main(int argc, char **argv)
{
char *indepQuantity, **depenQuantity, **exclude, **depenQuantityPair;
long depenQuantities, excludes;
char *input, *output;
long iArg, i, j, rows, readCode, noWarnings, items;
long rowsToUse;
unsigned long flags, pairFlags, tmpFlags, pipeFlags;
SCANNED_ARG *scArg;
SDDS_DATASET SDDSin, SDDSout;
double *tdata, *data, t0, dt;
double fracRMSChangeLimit, fracFreqAccuracyLimit;
int32_t frequenciesDesired, maxFrequencies, freqCycleLimit;
short truncate;
double *frequency, *amplitude=NULL, *phase=NULL, *significance=NULL, *phase1=NULL, *amplitude1=NULL, *significance1=NULL;
long frequenciesFound;
long *frequencyIndex, *amplitudeIndex, *phaseIndex, *significanceIndex, pairs;
long *amplitudeIndex1, *phaseIndex1, *significanceIndex1;
SDDS_RegisterProgramName(argv[0]);
#ifdef DEBUG
if (1) {
long code;
double x, y;
x = 1.1;
code = OneDFunctionOptimize(&y, &x, 0.07, -4, 4,
trialFn, 50, 1e-6, 0, 1);
fprintf(stderr, "code: %ld x=%e, y=%e\n", code, x, y);
x = .9;
code = OneDFunctionOptimize(&y, &x, 0.15, -4, 4,
trialFn, 50, 1e-6, 0, 1);
fprintf(stderr, "code: %ld x=%e, y=%e\n", code, x, y);
x = .999;
code = OneDFunctionOptimize(&y, &x, 0.11, -4, 4,
trialFn, 50, 1e-6, 0, 1);
fprintf(stderr, "code: %ld x=%e, y=%e\n", code, x, y);
exit(0);
}
#endif
argc = scanargs(&scArg, argc, argv);
if (argc<3) {
fprintf(stderr, "%s%s", USAGE1, USAGE2);
exit(1);
}
output = input = NULL;
flags = pipeFlags = excludes = truncate = pairFlags= 0;
indepQuantity = NULL;
depenQuantity = exclude = depenQuantityPair=NULL;
depenQuantities = 0;
noWarnings = 0;
fracRMSChangeLimit = 0.0;
fracFreqAccuracyLimit = 0.00001;
frequenciesDesired = 1;
maxFrequencies = 4;
freqCycleLimit = 100;
pairs=0;
for (iArg=1; iArg<argc; iArg++) {
if (scArg[iArg].arg_type==OPTION) {
/* process options here */
switch (match_string(scArg[iArg].list[0], option, N_OPTIONS, 0)) {
case SET_TRUNCATE:
truncate = 1;
break;
case SET_PAIR:
if (depenQuantities)
SDDS_Bomb("Invalid -pair option, the depent-quantity is provided by -column option already.");
if (scArg[iArg].n_items!=3)
SDDS_Bomb("invalid -pair syntax");
depenQuantity = SDDS_Realloc(depenQuantity, sizeof(*depenQuantity)*(pairs+1));
depenQuantityPair = SDDS_Realloc(depenQuantityPair, sizeof(*depenQuantityPair)*(pairs+1));
depenQuantity[pairs] = scArg[iArg].list[1];
depenQuantityPair[pairs] = scArg[iArg].list[2];
pairs++;
break;
case SET_COLUMN:
if (indepQuantity)
SDDS_Bomb("only one -column option may be given");
if (scArg[iArg].n_items<2)
SDDS_Bomb("invalid -column syntax");
indepQuantity = scArg[iArg].list[1];
if (scArg[iArg].n_items>=2) {
if (pairs)
SDDS_Bomb("Invalid -column syntax, the depent-quantity is provided by -pair option already.");
depenQuantity = tmalloc(sizeof(*depenQuantity)*(depenQuantities=scArg[iArg].n_items-2));
for (i=0; i<depenQuantities; i++)
depenQuantity[i] = scArg[iArg].list[i+2];
}
break;
case SET_PIPE:
if (!processPipeOption(scArg[iArg].list+1, scArg[iArg].n_items-1, &pipeFlags))
SDDS_Bomb("invalid -pipe syntax");
break;
case SET_EXCLUDE:
if (scArg[iArg].n_items<2)
SDDS_Bomb("invalid -exclude syntax");
moveToStringArray(&exclude, &excludes, scArg[iArg].list+1, scArg[iArg].n_items-1);
break;
case SET_NOWARNINGS:
noWarnings = 1;
break;
case SET_TERM_SEARCH:
items = scArg[iArg].n_items-1;
flags &= ~(NAFF_RMS_CHANGE_LIMIT|NAFF_FREQS_DESIRED|NAFF_MAX_FREQUENCIES);
fracRMSChangeLimit = 0;
frequenciesDesired = 0;
maxFrequencies = 10;
if (!scanItemList(&tmpFlags, scArg[iArg].list+1, &items, 0,
"changelimit", SDDS_DOUBLE, &fracRMSChangeLimit, 1,
NAFF_RMS_CHANGE_LIMIT,
"maxfrequencies", SDDS_LONG, &maxFrequencies, 1,
NAFF_MAX_FREQUENCIES,
"frequencies", SDDS_LONG, &frequenciesDesired, 1,
NAFF_FREQS_DESIRED,
NULL) ||
(tmpFlags&NAFF_RMS_CHANGE_LIMIT && tmpFlags&NAFF_FREQS_DESIRED) ||
maxFrequencies<1)
SDDS_Bomb("invalid -terminateSearch syntax");
flags |= tmpFlags;
if (frequenciesDesired)
maxFrequencies = frequenciesDesired;
break;
case SET_ITERATE_FREQ:
items = scArg[iArg].n_items - 1;
flags &= ~(NAFF_FREQ_CYCLE_LIMIT|NAFF_FREQ_ACCURACY_LIMIT);
if (!scanItemList(&tmpFlags, scArg[iArg].list+1, &items, 0,
"cyclelimit", SDDS_LONG, &freqCycleLimit, 1, NAFF_FREQ_CYCLE_LIMIT,
"accuracylimit", SDDS_DOUBLE, &fracFreqAccuracyLimit,
1, NAFF_FREQ_ACCURACY_LIMIT,
NULL) || !bitsSet(tmpFlags) || freqCycleLimit<2)
SDDS_Bomb("invalid -iterateFrequency syntax");
flags |= tmpFlags;
break;
default:
fprintf(stderr, "error: unknown/ambiguous option: %s\n",
scArg[iArg].list[0]);
exit(1);
break;
}
}
else {
if (!input)
input = scArg[iArg].list[0];
else if (!output)
output = scArg[iArg].list[0];
else
SDDS_Bomb("too many filenames seen");
}
}
processFilenames("sddsnaff", &input, &output, pipeFlags, 0, NULL);
if (!indepQuantity)
SDDS_Bomb("supply the independent quantity name with the -columns option");
if (!SDDS_InitializeInput(&SDDSin, input))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (SDDS_CheckColumn(&SDDSin, indepQuantity, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)
!=SDDS_CHECK_OKAY)
exit(1);
excludes = appendToStringArray(&exclude, excludes, indepQuantity);
if (pairs) {
pairFlags = flags | NAFF_FREQ_FOUND;
depenQuantities = pairs;
}
if (!depenQuantities)
depenQuantities = appendToStringArray(&depenQuantity, depenQuantities, "*");
if (!pairs) {
if ((depenQuantities=expandColumnPairNames(&SDDSin, &depenQuantity, NULL,
depenQuantities, exclude, excludes,
FIND_NUMERIC_TYPE, 0))<=0) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
SDDS_Bomb("No quantities selected to fft");
}
}
if (!SetupNAFFOutput(&SDDSout, output, &SDDSin, indepQuantity,
depenQuantities, depenQuantity,
&frequencyIndex, &litudeIndex, &phaseIndex,
&significanceIndex, depenQuantityPair,&litudeIndex1,
&phaseIndex1,&significanceIndex1))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!(frequency = SDDS_Malloc(sizeof(*frequency)*maxFrequencies)) ||
!(amplitude = SDDS_Malloc(sizeof(*amplitude)*maxFrequencies)) ||
!(phase = SDDS_Malloc(sizeof(*phase )*maxFrequencies)) ||
!(significance= SDDS_Malloc(sizeof(*significance)*maxFrequencies)))
SDDS_Bomb("memory allocation failure");
if (pairs) {
if (!(amplitude1 = SDDS_Malloc(sizeof(*amplitude1)*maxFrequencies)) ||
!(phase1 = SDDS_Malloc(sizeof(*phase1 )*maxFrequencies)) ||
!(significance1 = SDDS_Malloc(sizeof(*significance1)*maxFrequencies)))
SDDS_Bomb("memory allocation failure");
}
while ((readCode=SDDS_ReadPage(&SDDSin))>0) {
if ((rows = SDDS_CountRowsOfInterest(&SDDSin))<0)
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (rows) {
long primeRows;
rowsToUse = rows;
primeRows = greatestProductOfSmallPrimes(rows);
if (rows!=primeRows) {
if (truncate)
rowsToUse = greatestProductOfSmallPrimes(rows);
else if (largest_prime_factor(rows)>100 && !noWarnings)
fputs("Warning: number of points has large prime factors.\nThis could take a very long time.\nConsider using the -truncate option.\n", stderr);
}
if (!SDDS_StartPage(&SDDSout, maxFrequencies) ||
!SDDS_CopyParameters(&SDDSout, &SDDSin))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!(tdata = SDDS_GetColumnInDoubles(&SDDSin, indepQuantity)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (i=1; i<rowsToUse; i++)
if (tdata[i]<=tdata[i-1])
SDDS_Bomb("independent data is not monotonically increasing");
dt = (tdata[rowsToUse-1]-tdata[0])/(rowsToUse-1.0),
t0 = tdata[0];
free(tdata);
for (i=0; i<depenQuantities; i++) {
if (!(data = SDDS_GetColumnInDoubles(&SDDSin, depenQuantity[i])))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (j=0; j<maxFrequencies; j++)
frequency[j] = amplitude[j] = phase[j] = significance[j] = -1;
frequenciesFound = PerformNAFF(frequency, amplitude, phase, significance,
t0, dt,
data, rowsToUse, flags,
fracRMSChangeLimit, maxFrequencies,
freqCycleLimit, fracFreqAccuracyLimit, 0, 0);
#ifdef DEBUG
fprintf(stderr, "Column %s: ", depenQuantity[i]);
fprintf(stderr, "f=%10.3e a=%10.3e p=%10.3e s=%10.3e\n",
frequency[0], amplitude[0], phase[0], significance[0]);
#endif
free(data);
data = NULL;
if (pairs) {
if (!(data = SDDS_GetColumnInDoubles(&SDDSin, depenQuantityPair[i])))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
frequenciesFound = PerformNAFF(frequency, amplitude1, phase1, significance1,
t0, dt,
data, rowsToUse, pairFlags,
fracRMSChangeLimit, maxFrequencies,
freqCycleLimit, fracFreqAccuracyLimit, 0, 0);
for (j=0; j<maxFrequencies; j++)
if (frequency[j]!=-1)
frequency[j] = adjustFrequencyHalfPlane(frequency[j], phase[j], phase1[j], dt);
free(data);
data = NULL;
}
if (!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
frequency, maxFrequencies, frequencyIndex[i]) ||
!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
amplitude, maxFrequencies, amplitudeIndex[i]) ||
!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
phase, maxFrequencies, phaseIndex[i]) ||
!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
significance, maxFrequencies, significanceIndex[i]))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (pairs) {
if (!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
amplitude1, maxFrequencies, amplitudeIndex1[i]) ||
!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
phase1, maxFrequencies, phaseIndex1[i]) ||
!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_INDEX,
significance1, maxFrequencies, significanceIndex1[i]))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
}
else {
if (!SDDS_StartPage(&SDDSout, 0) || !SDDS_CopyParameters(&SDDSout, &SDDSin))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_WritePage(&SDDSout))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_Terminate(&SDDSin)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
if (!SDDS_Terminate(&SDDSout)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
free(frequency);
free(amplitude);
free(phase);
free(significance);
if (pairs) {
free(amplitude1);
free(phase1);
free(significance1);
free(amplitudeIndex1);
free(phaseIndex1);
free(significanceIndex1);
free(depenQuantityPair);
}
free(depenQuantity);
free(frequencyIndex);
free(amplitudeIndex);
free(phaseIndex);
free(significanceIndex);
return 0;
}
