int main ()
{
int numItems = 0, i, searchItem = 0, algoIdx = 0;
Boolean itemFound = FALSE;
printf ("\nEnter the number of items in search array (1-100): ");
while (1)
{
scanf ("%d", &numItems);
if ((numItems <= 100) && (numItems > 0))
{
break;
}
printf ("\nEntered value is greater than 100 or is negative, please enter a value between 1-100: ");
}
printf ("\nPlease enter the list of values to fill the search array:");
for (i = 0; i < numItems; i++)
{
scanf ("%d", &searchArr[i]);
}
while (1)
{
printf ("\nEnter the search item:");
scanf ("%d", &searchItem);
printf ("\nList of search algo's available:\n");
printf ("1) Linear search\n2) Linear search with sentinel\n3) Exit\n");
printf ("Choose one:");
scanf ("%d", &algoIdx);
switch (algoIdx)
{
case 1:
itemFound = linearSearch (numItems, searchItem);
break;
case 2:
itemFound = linearSearchSentinel (numItems, searchItem);
break;
case 3:
printf ("\nExiting...\n");
exit(0);
default:
printf ("\nOption not available, defaulting to Linear search!\n");
itemFound = linearSearch (numItems, searchItem);
break;
}
if (itemFound == TRUE)
{
printf ("Holy Cow!!! Item %d is found in the DB\n", searchItem);
}
else
{
printf ("Oops! The item you requested is not found in the DB\n");
}
}
return 0;
}
/*Main method, automated test*/
int main(){
int array[] = {1, 2, 3, 4};
printf("Start of Automated test\n\n");
/*Test for factorial*/
printf("Factorial Test Start\n");
if(factorial(0) == 1) printf("Passed\n");
else printf("Failed\n");
if(factorial(1) == 1) printf("Passed\n");
else printf("Failed\n");
if(factorial(6) == 720) printf("Passed\n\n");
else printf("Failed\n\n");
/*Test for Fibonacci*/
printf("Fibonacci Test Start\n\n");
if(fibonacci(0) == 0) printf("Passed\n");
else printf("Failed\n");
if(fibonacci(1) == 1) printf("Passed\n");
else printf("Failed\n");
if(fibonacci(6) == 8) printf("Passed\n\n");
else printf("Failed\n\n");
/*Test for linearSearch*/
printf("Linear Search Test Start\n\n");
if(linearSearch(array, 4, 3) == 2) printf("Passed\n");
else printf("Failed\n");
if(linearSearch(array, 4, 1) == 0) printf("Passed\n");
else printf("Failed\n");
if(linearSearch(array, 4, 4) == 3) printf("Passed\n\n");
else printf("Failed\n\n");
/*Test for Sumation*/
printf("Sumation Test Start\n\n");
if(sum(0) == 0) printf("Passed\n");
else printf("Failed\n");
if(sum(1) == 1) printf("Passed\n");
else printf("Failed\n");
if(sum(5) == 15) printf("Passed\n\n");
else printf("Failed\n\n");
printf("End of Automated test\n");
return 0;
}
int main() {
srand(time(NULL));
int sizeLijst = 10;
int* lijst = generateRandomList(sizeLijst);
printf("Lijst ongesorteerd: ");
printList(lijst, sizeLijst);
int teZoekenGetal;
do{
printf("Geef een getal (-1 = exit):");
scanf("%d*c",&teZoekenGetal);
if(teZoekenGetal != -1){
int indexGetal = linearSearch(lijst, sizeLijst, teZoekenGetal);
if (indexGetal==-1) {
printf("'%d' is niet gevonden in de lijst! ", teZoekenGetal);
} else {
printf("'%d' staat op positie %d in de lijst! ", teZoekenGetal, indexGetal);
}
printf("(#compares = %d)\n",compareCounter);
}
}while(teZoekenGetal != -1);
free(lijst);
return 0;
}
/* function main begins program execution */
int main( void )
{
int a[ SIZE ]; /* create array a */
int x; /* counter for initializing elements 0-99 of array a */
int searchKey; /* value to locate in array a */
int element; /* variable to hold location of searchKey or -1 */
/* create data */
for ( x = 0; x < SIZE; x++ ) {
a[ x ] = 2 * x;
} /* end for */
printf( "Enter integer search key:\n" );
scanf( "%d", &searchKey );
/* attempt to locate searchKey in array a */
element = linearSearch( a, searchKey, SIZE );
/* display results */
if ( element != -1 ) {
printf( "Found value in element %d\n", element );
} /* end if */
else {
printf( "Value not found\n" );
} /* end else */
return 0; /* indicates successful termination */
} /* end main */
int
main(int argc, char *argv[])
{
char *sorted_data[26] = {
"ALPHA","BRAVO","CHARLIE","DELTA","ECHO","FOXTROT","GOLF",
"HOTEL","INDIA","JULIET","KILO","LIMA","MIKE","NOVEMBER",
"OSCAR","PAPA","QUEBEC","ROMEO","SIERRA","TANGO","UNIFORM",
"VICTOR","WHISKY","X-RAY","YANKEE","ZULU",
};
int index;
printf("linear_search : \n");
index = linearSearch(sorted_data, 26, "TANGO");
printf("index = %d\n", index);
printf("\n");
printf("binary_search : \n");
index = binarySearch(sorted_data, 26, "TANGO");
printf("index = %d\n", index);
printf("\n");
printf("binary_search_recursive : \n");
index = binarySearch_recursive(sorted_data, 0, 26, "TANGO");
printf("index = %d\n", index);
printf("\n");
return 0;
}
int main(void){
int array[25]={5,6,7,1,2,3,-10,56,100,-1};
int location;
int key=-20;
location = linearSearch(key,array,10);
printf("the number %d was found at : %d\n",key,location);
selectionSort(array,10);
printArray(array,10,10);
}
int main()
{
int len = 8;
int A[8] = {0, 1, 2, 3, 4, 5, 6, 7};
printf("%d\n", linearSearch(A, len, 3));
printf("%d\n", binarySearch(A, len, 4));
return 0;
}
int linearSearch(int A[], int s, int i, int n){
if( i == n )
return -1;
if( A[i] == s )
return i;
return linearSearch(A, s, ++i, n);
}
int main()
{
int a[5] = {1,2,3,4,5};
int check = linearSearch(a,5,6);
if (check)
printf("found");
else
printf("not_found");
}
int main(int argc, char* argv[]){
// varible declarations
int i=0,j=0,length=0,*array=NULL, temp=0,key=0,found=0;
double arrayTime, nodeTime;
Node* head=NULL;
clock_t start,end;
key = atoi(argv[1]);// change string to integer
printf("%-15s%-15s\n","Linear search","Node Search");
//loop for all the argumens
for(i=2; i<argc; i++){
FILE* input = fopen(argv[i],"r");
if(input == NULL){
printf("Unable to open %s\n",argv[i]);
}
else{
fscanf(input,"%d",&length);
array = (int *)malloc(length*sizeof(int));
for(j=0;j<length;j++){
fscanf(input,"%d",&temp);
array[j] = temp;
head = insert_end(head, temp);
}
//timing the algorith
start = clock();
found = linearSearch(array,length,key);
end = clock();
arrayTime = (double)(end-start)/CLOCKS_PER_SEC;
//check if the search was found
if(found == 0){
printf("number not found in linear search\n");
}
start = clock();
found = nodeSearch(head, key);
end = clock();
nodeTime = (double)(end-start)/CLOCKS_PER_SEC;
if(found == 0){
printf("number not found in node search\n");
}
printf("%-15lf%-15lf\n",arrayTime,nodeTime);
//free the malloced memory
free(array);
free_node(head);
head = NULL;
}
close(input);//close the input file
}
}
void SelectionRaster::updateSelection(TRasterCM32P cm,
const BlendParam ¶m) {
// Make a hard copy of color indexes. We do so since we absolutely prefer
// having them SORTED!
std::vector<int> cIndexes = param.colorsIndexes;
std::sort(cIndexes.begin(), cIndexes.end());
unsigned int lx = cm->getLx(), ly = cm->getLy(), wrap = cm->getWrap();
// Scan each cm pixel, looking if its ink or paint is in param's colorIndexes.
cm->lock();
TPixelCM32 *pix, *pixBegin = (TPixelCM32 *)cm->getRawData();
SelectionData *selData = data();
const int *v =
&cIndexes[0]; // NOTE: cIndexes.size() > 0 due to external check.
unsigned int vSize = cIndexes.size();
unsigned int i, j;
// NOTE: It seems that linear searches are definitely best for small color
// indexes.
if (vSize > 50) {
for (i = 0; i < ly; ++i) {
pix = pixBegin + i * wrap;
for (j = 0; j < lx; ++j, ++pix, ++selData) {
selData->m_selectedInk = binarySearch(v, vSize, pix->getInk());
selData->m_selectedPaint = binarySearch(v, vSize, pix->getPaint());
}
}
} else {
for (i = 0; i < ly; ++i) {
pix = pixBegin + i * wrap;
for (j = 0; j < lx; ++j, ++pix, ++selData) {
selData->m_selectedInk = linearSearch(v, vSize, pix->getInk());
selData->m_selectedPaint = linearSearch(v, vSize, pix->getPaint());
}
}
}
cm->unlock();
}
void main(void)
{
int * intArrays[COPIES], i, arraySize, value;
clrscr();
printf("This program sorts and searches integer values!\n");
printf("please give me number of values you wish to deal with: ");
scanf("%d", &arraySize);
for(i = 0;i < COPIES; i++)
intArrays[i] = (int *) malloc(sizeof(int) * arraySize);
readValues(intArrays, arraySize);
printf("Enter number to search for? (linear search): ");
scanf("%d", &value);
if (linearSearch(intArrays[0], arraySize, value) != -1)
printf("Found !\n");
else
printf("Not Found!\n");
getch();
printValues(intArrays, arraySize);
printf("\nSorting Array 1 using bubble....\n");
bubble(intArrays[0], arraySize);
printValues(intArrays, arraySize);
printf("\nSorting Array 2 using selection....\n");
selection(intArrays[1], arraySize);
printValues(intArrays, arraySize);
printf("\nSorting Array 3 using insertion....\n");
insertion(intArrays[2], arraySize);
printValues(intArrays, arraySize);
printf("Enter number to search for? (binary search): ");
scanf("%d", &value);
if (linearSearch(intArrays[0], arraySize, value) != -1)
printf("Found !\n");
else
printf("Not Found!\n");
getch();
}
/*
* Summary: Adjusts the vote count based on a recent vote.
* Parameters: u32 index of the node that voted, u32 ballot of the node.
* Return: None.
*/
void
voteCount(u32 NODE_INDEX, u32 BALLOT)
{
if (NODE_INDEX < 0)
{
logNormal("voteCount: Invalid node index %d", NODE_INDEX);
API_ASSERT_GREATER_EQUAL(NODE_INDEX, 0); // blinkcode!
}
if (BALLOT < 0)
{
logNormal("voteCount: Invalid ballot %d", BALLOT);
API_ASSERT_GREATER_EQUAL(BALLOT, 0); // blinkcode!
}
if (0 == BALLOT) // 0 is never a correct answer
return; // But it's not worth blinkcoding over
else if (BALLOT == VOTE_NODE_ARR[NODE_INDEX])
return; // Ignore duplicate votes
// Invalid vote if I've already voted (didn't flush from a new calculation)
else if (0 != VOTE_NODE_ARR[NODE_INDEX])
return;
else if (0 == VOTE_NODE_ARR[NODE_INDEX]) // Haven't voted yet
++VOTE_COUNT; // This is the first vote received
if (VOTE_COUNT > NODE_COUNT) // Someone voted multiple times
{
flush(); // Clean out memory
voteCount(0, calculate(HOST_CALC)); // Recount our own vote
return;
}
// look to see if the ballot is for an existing candidate
u32 k = linearSearch(CANDIDATE_ARR, CANDIDATE_COUNT + 1, BALLOT);
if (INVALID != k) // if so, give him a vote
++CANDIDATE_VOTES_ARR[k];
else // otherwise the ballot is new to the candidate list
{ // so add it
k = CANDIDATE_COUNT++; // Give him a vote
CANDIDATE_ARR[k] = BALLOT; // Add the new candidate to the nominations list
++CANDIDATE_VOTES_ARR[k]; // Give the candidate a vote
}
VOTE_NODE_ARR[NODE_INDEX] = BALLOT; // record the node's ballot
evalMajority(); //Reevaluate the majority with every different ballot
return;
}
//Recursive Version of Linear Serach
//Returns the number if found
//returns -1 if not found
int linearSearch(int a[], int n, int key)
{
if (n < 0 )
{
return -1;
}
if(key == a[n-1])
{
return n - 1;
}
return linearSearch(a, n-1, key);
}
int main(void)
{
double testArray[] = {0, 3, 4, 2};
int begin = 0, end = 3;
double searchValue = 3;
int index;
index = linearSearch(testArray, begin, end, searchValue);
printf("%d\n", index);
return 0;
}
int main()
{
int a[SIZE] = {9,4,5,1,7,78,22,15,96,45}, key, pos;
printf("Enter the search key :\n");
scanf("%d", &key);
pos = linearSearch(a,key);
if(pos == -1)
printf("the search key is not in array\n");
else
printf("the search key %d is at location %d\n", key, pos);
return 0;
}
//Main Function
int main() {
//Memory-efficient array
int n;
scanf("%d",&n);
int arr[n],key,x;
//Key for element to search
printf("Enter the value of the key");
scanf("%d",&key);
//Function call
linearSearch(arr,n,key);
return 0;
}
/*Linear Search with recursion*/
int linearSearch(const int array[], int length, int value) {
//searching backwards from the size to 0 (Termination code)
if(length==0){
return -1;
}
//if the element if found we return the position
else if (array[length-1]==value) {
return length-1;
}
//else we keep searching (recursive code)
else{
return linearSearch( array, length-1, value);
}
}
int main() {
int searchFor = 0;
printf("What number would you like to search for?\n");
scanf("%d", &searchFor);
printf("Right-o, searching for %d!\n", searchFor);
for (int i = 0; i < arraySize; i++) {
printf("Index #%d: %d\n", i, primes[i]);
}
searchResult lSearchResult = linearSearch(&primes, arraySize, searchFor);
printf("Linear search for %d completed. Found target value at index %d, in %d guesses.\n", searchFor, lSearchResult.index, lSearchResult.numberOfGuesses);
return 0;
}
int main()
{
// varaiables
int arrList[] = {121, 103, 69, 87, 110, 12, 55, 47, 35, 63, 6, 79, 8, 95, 3, 130, 21, 1 };
int value = 55;
bool result = linearSearch(arrList, value);
if (result == true)
{
printf("Number was found!\n");
}
else
{
printf("Number was NOT found!\n");
}
return 0;
}
int main()
{
int a[100], i, n, sval,found=0;
printf("Enter size of array: ");
scanf("%d",&n);
printf("enter element of array: ");
for(i=1; i<=n; i++)
scanf("%d",&a[i]);
printf("Enter search value: ");
scanf("%d",&sval);
found = linearSearch(a,n,sval);
if(found == 1)
{
printf("value found in %d index\n",index-1);
}
else
{
printf("value not found");
}
return 0;
}
void printMenu(){
int ch,x,y;
printf("\nMAIN MENU");
printf("\n1.Linear Search for x");
printf("\n2.Binary Search for x");
printf("\n3.Number of repetitions for x");
printf("\nEnter your choice ");
scanf("%d", &ch);
switch (ch){
case 1: printf("\nEnter the number you want to search ");
scanf("%d", &x);
begin = clock();
linearSearch(A,x);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\nRun Time %f", time_spent);
break;
case 2: printf("\nEnter the number you want to search ");
scanf("%d", &x);
begin = clock();
binarySearch(A,x);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\nRun time %f", time_spent);
break;
case 3: printf("\nEnter the number you want to search ");
scanf("%d", &x);
begin = clock();
y = reps(A,x);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\nNumber of repetitions for the number: %d", y);
printf("\nRun time %f", time_spent);
break;
default: printf("\nInvalid option ");
break;
}
}
int main() {
int A[MAX], n, i, s;
printf("Enter Number of Elements: ");
scanf("%d", &n);
printf("Enter %d Elements:\n", n);
for(i=0; i<n; i++)
scanf("%d", &A[i]);
printf("Enter Element to Search: ");
scanf("%d", &s);
i = linearSearch(A, s, 0, n) ;
if( i != -1 )
printf("%d found at index %d\n", s, i+1);
else
printf("%d not found\n", s);
return 0;
}
Exosystem* Data::search(Exoplanet& key, char sortingKey) const
{
Exoplanet* result;
if (sortingKey == 'N')
{
result = new Exoplanet(key);
Exoplanet** temp = hashTable->search(result);
if (temp == nullptr) result = nullptr;
else result = *temp;
}
else if (isSortedOnKey == sortingKey)
{
result = binarySearch(key, *planets, sortingKey);
}
else
{
result = linearSearch(key, *planets, sortingKey);
}
if (result == nullptr) return nullptr;
return result->getSystemPointer();
}
int main(){
int list[10];
int i,n,no,val;
printf("Enter number of arrays\n");
scanf("%d",&n);
printf("Enter Numbers in an array:\n");
for (i = 0; i < n; i++)
{
scanf("%d",&list[i]);
}
printf("Enter number to be Searched:\t");
scanf("%d",&no);
val=linearSearch(list,n,no);
if (val!=-1)
{
/* 23code */
printf("Item found at position: %d \n",val);
}
else{
printf("Not Found\n");
}
return 0;
}
main()
{
int i=0,j=0,num,distinct
;
int a[10];
while(i<10)
{
distinct=0;
j=0;
while(j<10)
{
scanf("%d",&num);
if(linearSearch(a,(num%42),j))
{
distinct++;
}
a[j]=num%42;
j++;
}
printf("%d\n",distinct);
i++;
}
}
int main()
{
//variable declrations
int myArray[50], myArray2[] = {1, 2, 3, 4, 5}, myArray3[] = {1, 2, 3, 4, 5};
int index, searchResults, key;
//testing fillArray
fillArray(myArray, 50, 1000);
//testing printNperline()
printf("Before sort printing 10 per line\n");
printNperline(myArray, 50, 10);
printf("\n");
printf("Before sort printing 4 per line\n");
printNperline(myArray, 50, 4);
printf("\n");
printf("Before sort printing 6 per line\n");
printNperline(myArray, 50, 6);
//testing bubble sort on myArray
bubbleSort(myArray, 50);
//printing myArray after sort
printf("\n");
printf("After sort printing 6 per line\n");
printNperline(myArray, 50, 6);
printf("\n");
printf("After sort printing 15 per line\n");
printNperline(myArray, 50, 15);
printf("\n");
printf("After sort printing 11 per line\n");
printNperline(myArray, 50, 11);
//testing linear search
printf("\n");
printf("Testing linear search for 82\n");
key = 82;
searchResults = linearSearch(myArray, 50, key);
if(searchResults >= 0)
printf("The key value %d was found in myArray at position %d\n", key, searchResults);
else
printf("The key value %d was not found in myArray\n", key);
printf("\n");
printf("Testing linear search for %d which is the last element in the array\n", myArray[49]);
key = myArray[49];
searchResults = linearSearch(myArray, 50, key);
if(searchResults >= 0)
printf("The key value %d was found in myArray at position %d\n", key, searchResults);
else
printf("The key value %d was not found in myArray\n", key);
printf("\n");
printf("Testing linear search for %d which is the first element in the array\n", myArray[0]);
key = myArray[0];
searchResults = linearSearch(myArray, 50, key);
if(searchResults >= 0)
printf("The key value %d was found in myArray at position %d\n", key, searchResults);
else
printf("The key value %d was not found in myArray\n", key);
//testing shiftElements
printf("\n");
printf("Shifting the elements in the array right 6 elements\n");
shiftElements(myArray, 50, 6);
printNperline(myArray, 50, 10);
printf("\n");
printf("Shifting the elements in the array left 4 elements\n");
shiftElements(myArray, 50, -4);
printNperline(myArray, 50, 10);
}
int16_t linex_node_handler::locate() {
pos = linearSearch();
return pos;
}
/*
* This routine is a bounds-constrained truncated-newton method.
* the truncated-newton method is preconditioned by a limited-memory
* quasi-newton method (this preconditioning strategy is developed
* in this routine) with a further diagonal scaling
* (see routine diagonalscaling).
*/
static tnc_rc tnc_minimize(int n, double x[],
double *f, double gfull[], tnc_function *function, void *state,
double xscale[], double xoffset[], double *fscale,
double low[], double up[], tnc_message messages,
int maxCGit, int maxnfeval, int *nfeval, int *niter, double eta, double
stepmx, double accuracy, double fmin, double ftol, double xtol, double
pgtol, double rescale, tnc_callback *callback)
{
double fLastReset, difnew, epsmch, epsred, oldgtp,
difold, oldf, xnorm, newscale,
gnorm, ustpmax, fLastConstraint, spe, yrsr, yksk,
*temp = NULL, *sk = NULL, *yk = NULL, *diagb = NULL, *sr = NULL,
*yr = NULL, *oldg = NULL, *pk = NULL, *g = NULL;
double alpha = 0.0; /* Default unused value */
int i, icycle, oldnfeval, *pivot = NULL, frc;
logical lreset, newcon, upd1, remcon;
tnc_rc rc = TNC_ENOMEM; /* Default error */
*niter = 0;
/* Allocate temporary vectors */
oldg = malloc(sizeof(*oldg)*n);
if (oldg == NULL) goto cleanup;
g = malloc(sizeof(*g)*n);
if (g == NULL) goto cleanup;
temp = malloc(sizeof(*temp)*n);
if (temp == NULL) goto cleanup;
diagb = malloc(sizeof(*diagb)*n);
if (diagb == NULL) goto cleanup;
pk = malloc(sizeof(*pk)*n);
if (pk == NULL) goto cleanup;
sk = malloc(sizeof(*sk)*n);
if (sk == NULL) goto cleanup;
yk = malloc(sizeof(*yk)*n);
if (yk == NULL) goto cleanup;
sr = malloc(sizeof(*sr)*n);
if (sr == NULL) goto cleanup;
yr = malloc(sizeof(*yr)*n);
if (yr == NULL) goto cleanup;
pivot = malloc(sizeof(*pivot)*n);
if (pivot == NULL) goto cleanup;
/* Initialize variables */
epsmch = mchpr1();
difnew = 0.0;
epsred = 0.05;
upd1 = TNC_TRUE;
icycle = n - 1;
newcon = TNC_TRUE;
/* Uneeded initialisations */
lreset = TNC_FALSE;
yrsr = 0.0;
yksk = 0.0;
/* Initial scaling */
scalex(n, x, xscale, xoffset);
(*f) *= *fscale;
/* initial pivot calculation */
setConstraints(n, x, pivot, xscale, xoffset, low, up);
dcopy1(n, gfull, g);
scaleg(n, g, xscale, *fscale);
/* Test the lagrange multipliers to see if they are non-negative. */
for (i = 0; i < n; i++)
if (-pivot[i] * g[i] < 0.0)
pivot[i] = 0;
project(n, g, pivot);
/* Set initial values to other parameters */
gnorm = dnrm21(n, g);
fLastConstraint = *f; /* Value at last constraint */
fLastReset = *f; /* Value at last reset */
if (messages & TNC_MSG_ITER) fprintf(stderr,
" NIT NF F GTG\n");
if (messages & TNC_MSG_ITER) printCurrentIteration(n, *f / *fscale, gfull,
*niter, *nfeval, pivot);
/* Set the diagonal of the approximate hessian to unity. */
for (i = 0; i < n; i++) diagb[i] = 1.0;
/* Start of main iterative loop */
while(TNC_TRUE)
{
/* Local minimum test */
if (dnrm21(n, g) <= pgtol * (*fscale))
{
/* |PG| == 0.0 => local minimum */
dcopy1(n, gfull, g);
project(n, g, pivot);
if (messages & TNC_MSG_INFO) fprintf(stderr,
"tnc: |pg| = %g -> local minimum\n", dnrm21(n, g) / (*fscale));
rc = TNC_LOCALMINIMUM;
break;
}
/* Terminate if more than maxnfeval evaluations have been made */
if (*nfeval >= maxnfeval)
{
rc = TNC_MAXFUN;
break;
}
/* Rescale function if necessary */
newscale = dnrm21(n, g);
if ((newscale > epsmch) && (fabs(log10(newscale)) > rescale))
{
newscale = 1.0/newscale;
*f *= newscale;
*fscale *= newscale;
gnorm *= newscale;
fLastConstraint *= newscale;
fLastReset *= newscale;
difnew *= newscale;
for (i = 0; i < n; i++) g[i] *= newscale;
for (i = 0; i < n; i++) diagb[i] = 1.0;
upd1 = TNC_TRUE;
icycle = n - 1;
newcon = TNC_TRUE;
if (messages & TNC_MSG_INFO) fprintf(stderr,
"tnc: fscale = %g\n", *fscale);
}
dcopy1(n, x, temp);
project(n, temp, pivot);
xnorm = dnrm21(n, temp);
oldnfeval = *nfeval;
/* Compute the new search direction */
frc = tnc_direction(pk, diagb, x, g, n, maxCGit, maxnfeval, nfeval,
upd1, yksk, yrsr, sk, yk, sr, yr,
lreset, function, state, xscale, xoffset, *fscale,
pivot, accuracy, gnorm, xnorm, low, up);
if (frc == -1)
{
rc = TNC_ENOMEM;
break;
}
if (frc)
{
rc = TNC_USERABORT;
break;
}
if (!newcon)
{
if (!lreset)
{
/* Compute the accumulated step and its corresponding gradient
difference. */
dxpy1(n, sk, sr);
dxpy1(n, yk, yr);
icycle++;
}
else
{
/* Initialize the sum of all the changes */
dcopy1(n, sk, sr);
dcopy1(n, yk, yr);
fLastReset = *f;
icycle = 1;
}
}
dcopy1(n, g, oldg);
oldf = *f;
oldgtp = ddot1(n, pk, g);
/* Maximum unconstrained step length */
ustpmax = stepmx / (dnrm21(n, pk) + epsmch);
/* Maximum constrained step length */
spe = stepMax(ustpmax, n, x, pk, pivot, low, up, xscale, xoffset);
if (spe > 0.0)
{
ls_rc lsrc;
/* Set the initial step length */
alpha = initialStep(*f, fmin / (*fscale), oldgtp, spe);
/* Perform the linear search */
lsrc = linearSearch(n, function, state, low, up,
xscale, xoffset, *fscale, pivot,
eta, ftol, spe, pk, x, f, &alpha, gfull, maxnfeval, nfeval);
if (lsrc == LS_ENOMEM)
{
rc = TNC_ENOMEM;
break;
}
if (lsrc == LS_USERABORT)
{
rc = TNC_USERABORT;
break;
}
if (lsrc == LS_FAIL)
{
rc = TNC_LSFAIL;
break;
}
/* If we went up to the maximum unconstrained step, increase it */
if (alpha >= 0.9 * ustpmax)
{
stepmx *= 1e2;
if (messages & TNC_MSG_INFO) fprintf(stderr,
"tnc: stepmx = %g\n", stepmx);
}
/* If we went up to the maximum constrained step,
a new constraint was encountered */
if (alpha - spe >= -epsmch * 10.0)
{
newcon = TNC_TRUE;
}
else
{
/* Break if the linear search has failed to find a lower point */
if (lsrc != LS_OK)
{
if (lsrc == LS_MAXFUN) rc = TNC_MAXFUN;
else rc = TNC_LSFAIL;
break;
}
newcon = TNC_FALSE;
}
}
else
{
/* Maximum constrained step == 0.0 => new constraint */
newcon = TNC_TRUE;
}
if (newcon)
{
if(!addConstraint(n, x, pk, pivot, low, up, xscale, xoffset))
{
if(*nfeval == oldnfeval)
{
rc = TNC_NOPROGRESS;
break;
}
}
fLastConstraint = *f;
}
(*niter)++;
/* Invoke the callback function */
if (callback)
{
unscalex(n, x, xscale, xoffset);
callback(x, state);
scalex(n, x, xscale, xoffset);
}
/* Set up parameters used in convergence and resetting tests */
difold = difnew;
difnew = oldf - *f;
/* If this is the first iteration of a new cycle, compute the
percentage reduction factor for the resetting test */
if (icycle == 1)
{
if (difnew > difold * 2.0) epsred += epsred;
if (difnew < difold * 0.5) epsred *= 0.5;
}
dcopy1(n, gfull, g);
scaleg(n, g, xscale, *fscale);
dcopy1(n, g, temp);
project(n, temp, pivot);
gnorm = dnrm21(n, temp);
/* Reset pivot */
remcon = removeConstraint(oldgtp, gnorm, pgtol * (*fscale), *f,
fLastConstraint, g, pivot, n);
/* If a constraint is removed */
if (remcon)
{
/* Recalculate gnorm and reset fLastConstraint */
dcopy1(n, g, temp);
project(n, temp, pivot);
gnorm = dnrm21(n, temp);
fLastConstraint = *f;
}
if (!remcon && !newcon)
{
/* No constraint removed & no new constraint : tests for convergence */
if (fabs(difnew) <= ftol * (*fscale))
{
if (messages & TNC_MSG_INFO) fprintf(stderr,
"tnc: |fn-fn-1] = %g -> convergence\n", fabs(difnew) / (*fscale));
rc = TNC_FCONVERGED;
break;
}
if (alpha * dnrm21(n, pk) <= xtol)
{
if (messages & TNC_MSG_INFO) fprintf(stderr,
"tnc: |xn-xn-1] = %g -> convergence\n", alpha * dnrm21(n, pk));
rc = TNC_XCONVERGED;
break;
}
}
project(n, g, pivot);
if (messages & TNC_MSG_ITER) printCurrentIteration(n, *f / *fscale, gfull,
*niter, *nfeval, pivot);
/* Compute the change in the iterates and the corresponding change in the
gradients */
if (!newcon)
{
for (i = 0; i < n; i++)
{
yk[i] = g[i] - oldg[i];
sk[i] = alpha * pk[i];
}
/* Set up parameters used in updating the preconditioning strategy */
yksk = ddot1(n, yk, sk);
if (icycle == (n - 1) || difnew < epsred * (fLastReset - *f))
lreset = TNC_TRUE;
else
{
yrsr = ddot1(n, yr, sr);
if (yrsr <= 0.0) lreset = TNC_TRUE;
else lreset = TNC_FALSE;
}
upd1 = TNC_FALSE;
}
}
if (messages & TNC_MSG_ITER) printCurrentIteration(n, *f / *fscale, gfull,
*niter, *nfeval, pivot);
/* Unscaling */
unscalex(n, x, xscale, xoffset);
coercex(n, x, low, up);
(*f) /= *fscale;
cleanup:
if (oldg) free(oldg);
if (g) free(g);
if (temp) free(temp);
if (diagb) free(diagb);
if (pk) free(pk);
if (sk) free(sk);
if (yk) free(yk);
if (sr) free(sr);
if (yr) free(yr);
if (pivot) free(pivot);
return rc;
}
