363 lines
8.9 KiB
C
363 lines
8.9 KiB
C
#include "DotProdTest.h"
|
|
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/*unknown declaration named translation_unit*/
|
|
/**
|
|
* Variable Declarations
|
|
*/
|
|
|
|
/**
|
|
* Function Definitions
|
|
*/
|
|
|
|
|
|
double dot_vector_lessthan_double_greaterthan__vector_lessthan_double_greaterthan_(vector_lessthan_double_greaterthan_ a, vector_lessthan_double_greaterthan_ b)
|
|
{
|
|
if (((((a).size))<(((b).size))))
|
|
{
|
|
println_char_P__("Error: Vectors not of same size") ;
|
|
print_char_P__("Vector a is of size: ") ;
|
|
println_int(((a).size)) ;
|
|
print_char_P__("Vector b is of size: ") ;
|
|
println_int(((b).size)) ;
|
|
println_char_P__("Did you know that Grover Cleveland served two seperate terms as President of the United States, four years apart?") ;
|
|
};
|
|
;
|
|
double ans = 0;;
|
|
for ( int i = 0;((i)<(lesser_lessthan_int_greaterthan__int_int(((a).size), ((b).size)) )); i++)
|
|
{
|
|
ans = ((ans)+(((vector_lessthan_double_greaterthan___at_int(&a,i) )*(vector_lessthan_double_greaterthan___at_int(&b,i) ))));
|
|
};
|
|
;
|
|
println_double(ans) ;
|
|
return ans;
|
|
}
|
|
int main()
|
|
{
|
|
vector_lessthan_double_greaterthan_ aVec; vector_lessthan_double_greaterthan___construct(&aVec) /*Init Position Call*/;
|
|
vector_lessthan_double_greaterthan_ bVec; vector_lessthan_double_greaterthan___construct(&bVec) /*Init Position Call*/;
|
|
double j;;
|
|
for ( int i = 0;((i)<(4)); i++)
|
|
{
|
|
j = ((i)+(0.0));
|
|
vector_lessthan_double_greaterthan___addEnd_double(&aVec,j) ;
|
|
vector_lessthan_double_greaterthan___addEnd_double(&bVec,j) ;
|
|
};
|
|
;
|
|
vector_lessthan_double_greaterthan___addEnd_double(&bVec,12.3) ;
|
|
double dotProd = dot_vector_lessthan_double_greaterthan__vector_lessthan_double_greaterthan_(aVec, bVec) ;;
|
|
return 0;
|
|
vector_lessthan_double_greaterthan___destruct(&aVec);
|
|
vector_lessthan_double_greaterthan___destruct(&bVec);
|
|
}
|
|
void print_char_P__(char* toPrint)
|
|
{
|
|
{
|
|
|
|
printf(toPrint);
|
|
;
|
|
};
|
|
return;
|
|
}
|
|
void print_string(string toPrint)
|
|
{
|
|
print_char_P__(string__toCharArray(&toPrint) ) ;
|
|
}
|
|
void print_int(int toPrint)
|
|
{
|
|
{
|
|
|
|
printf("%d", toPrint);
|
|
;
|
|
};
|
|
return;
|
|
}
|
|
void print_float(float toPrint)
|
|
{
|
|
{
|
|
|
|
printf("%f", toPrint);
|
|
;
|
|
};
|
|
return;
|
|
}
|
|
void print_double(double toPrint)
|
|
{
|
|
{
|
|
|
|
printf("%f", toPrint);
|
|
;
|
|
};
|
|
return;
|
|
}
|
|
void println()
|
|
{
|
|
print_char_P__("\n") ;
|
|
}
|
|
void println_char_P__(char* toPrint)
|
|
{
|
|
print_char_P__(toPrint) ;
|
|
println() ;
|
|
}
|
|
void println_string(string toPrint)
|
|
{
|
|
println_char_P__(string__toCharArray(&toPrint) ) ;
|
|
}
|
|
void println_int(int toPrint)
|
|
{
|
|
print_int(toPrint) ;
|
|
println() ;
|
|
}
|
|
void println_float(float toPrint)
|
|
{
|
|
print_float(toPrint) ;
|
|
println() ;
|
|
}
|
|
void println_double(double toPrint)
|
|
{
|
|
print_double(toPrint) ;
|
|
println() ;
|
|
}
|
|
void delete_lessthan_char_greaterthan__char_P__(char* toDelete)
|
|
{
|
|
free(toDelete) ;
|
|
}
|
|
void delete_lessthan_char_greaterthan__char_P___int(char* toDelete, int itemCount)
|
|
{
|
|
delete_lessthan_char_greaterthan__char_P__(toDelete) ;
|
|
}
|
|
void delete_lessthan_double_greaterthan__double_P__(double* toDelete)
|
|
{
|
|
free(toDelete) ;
|
|
}
|
|
void delete_lessthan_double_greaterthan__double_P___int(double* toDelete, int itemCount)
|
|
{
|
|
delete_lessthan_double_greaterthan__double_P__(toDelete) ;
|
|
}
|
|
char* malloc_lessthan_char_greaterthan__int(int size)
|
|
{
|
|
char* memPtr = 0;;
|
|
{
|
|
|
|
memPtr = malloc(size);
|
|
;
|
|
};
|
|
return memPtr;
|
|
}
|
|
double* malloc_lessthan_double_greaterthan__int(int size)
|
|
{
|
|
double* memPtr = 0;;
|
|
{
|
|
|
|
memPtr = malloc(size);
|
|
;
|
|
};
|
|
return memPtr;
|
|
}
|
|
char* new_lessthan_char_greaterthan__int(int count)
|
|
{
|
|
return malloc_lessthan_char_greaterthan__int(((sizeof_lessthan_char_greaterthan_() )*(count))) ;
|
|
}
|
|
double* new_lessthan_double_greaterthan__int(int count)
|
|
{
|
|
return malloc_lessthan_double_greaterthan__int(((sizeof_lessthan_double_greaterthan_() )*(count))) ;
|
|
}
|
|
int sizeof_lessthan_char_greaterthan_()
|
|
{
|
|
int result = 0;;
|
|
char testObj;;
|
|
{
|
|
|
|
result = sizeof(testObj);
|
|
;
|
|
};
|
|
return result;
|
|
}
|
|
int sizeof_lessthan_double_greaterthan_()
|
|
{
|
|
int result = 0;;
|
|
double testObj;;
|
|
{
|
|
|
|
result = sizeof(testObj);
|
|
;
|
|
};
|
|
return result;
|
|
}/* Method Definitions for string */
|
|
|
|
string* string__construct(string* this)
|
|
{
|
|
vector_lessthan_char_greaterthan___construct(&this->data) ;
|
|
return this;
|
|
}
|
|
|
|
string* string__construct_char_P__(string* this, char* str)
|
|
{
|
|
vector_lessthan_char_greaterthan___construct(&this->data) ;
|
|
while (*(str))
|
|
{
|
|
vector_lessthan_char_greaterthan___addEnd_char(&this->data,*(str)) ;
|
|
str = ((str)+(1));
|
|
};
|
|
;
|
|
return this;
|
|
}
|
|
|
|
char* string__toCharArray(string* this)
|
|
{
|
|
char* out = new_lessthan_char_greaterthan__int(((this->data).size)) ;;
|
|
for ( int i = 0;((i)<(((this->data).size))); i++)
|
|
(out)[i] = vector_lessthan_char_greaterthan___get_int(&this->data,i) ;
|
|
;
|
|
return out;
|
|
}
|
|
/* Done with string */
|
|
|
|
int lesser_lessthan_int_greaterthan__int_int(int a, int b)
|
|
{
|
|
if (((a)>(b)))
|
|
return b;
|
|
;
|
|
return a;
|
|
}/* Method Definitions for vector<char> */
|
|
|
|
vector_lessthan_char_greaterthan_* vector_lessthan_char_greaterthan___construct(vector_lessthan_char_greaterthan_* this)
|
|
{
|
|
this->size = 0;
|
|
this->available = 8;
|
|
this->data = new_lessthan_char_greaterthan__int(8) ;
|
|
return this;
|
|
}
|
|
|
|
void vector_lessthan_char_greaterthan___destruct(vector_lessthan_char_greaterthan_* this)
|
|
{
|
|
delete_lessthan_char_greaterthan__char_P__(this->data) ;
|
|
}
|
|
|
|
bool vector_lessthan_char_greaterthan___resize_int(vector_lessthan_char_greaterthan_* this, int newSize)
|
|
{
|
|
char* newData = new_lessthan_char_greaterthan__int(newSize) ;;
|
|
if (!(newData))
|
|
return false;
|
|
;
|
|
for ( int i = 0;((i)<(lesser_lessthan_int_greaterthan__int_int(this->size, newSize) )); i++)
|
|
(newData)[i] = (this->data)[i];
|
|
;
|
|
delete_lessthan_char_greaterthan__char_P___int(this->data, 0) ;
|
|
this->data = newData;
|
|
this->available = newSize;
|
|
return true;
|
|
}
|
|
|
|
char vector_lessthan_char_greaterthan___at_int(vector_lessthan_char_greaterthan_* this, int index)
|
|
{
|
|
return vector_lessthan_char_greaterthan___get_int(this,index) ;
|
|
}
|
|
|
|
char vector_lessthan_char_greaterthan___get_int(vector_lessthan_char_greaterthan_* this, int index)
|
|
{
|
|
if (((((index)<(0)))||(((index)>=(this->size)))))
|
|
{
|
|
return (this->data)[0];
|
|
};
|
|
;
|
|
return (this->data)[index];
|
|
}
|
|
|
|
char* vector_lessthan_char_greaterthan___getBackingMemory(vector_lessthan_char_greaterthan_* this)
|
|
{
|
|
return this->data;
|
|
}
|
|
|
|
void vector_lessthan_char_greaterthan___set_int_char(vector_lessthan_char_greaterthan_* this, int index, char dataIn)
|
|
{
|
|
if (((((index)<(0)))||(((index)>=(this->size)))))
|
|
return;
|
|
;
|
|
(this->data)[index] = dataIn;
|
|
}
|
|
|
|
void vector_lessthan_char_greaterthan___addEnd_char(vector_lessthan_char_greaterthan_* this, char dataIn)
|
|
{
|
|
this->size++;
|
|
if (((this->size)>=(this->available)))
|
|
vector_lessthan_char_greaterthan___resize_int(this,((this->size)*(2))) ;
|
|
;
|
|
(this->data)[((this->size)-(1))] = dataIn;
|
|
}
|
|
/* Done with vector<char> */
|
|
/* Method Definitions for vector<double> */
|
|
|
|
vector_lessthan_double_greaterthan_* vector_lessthan_double_greaterthan___construct(vector_lessthan_double_greaterthan_* this)
|
|
{
|
|
this->size = 0;
|
|
this->available = 8;
|
|
this->data = new_lessthan_double_greaterthan__int(8) ;
|
|
return this;
|
|
}
|
|
|
|
void vector_lessthan_double_greaterthan___destruct(vector_lessthan_double_greaterthan_* this)
|
|
{
|
|
delete_lessthan_double_greaterthan__double_P__(this->data) ;
|
|
}
|
|
|
|
bool vector_lessthan_double_greaterthan___resize_int(vector_lessthan_double_greaterthan_* this, int newSize)
|
|
{
|
|
double* newData = new_lessthan_double_greaterthan__int(newSize) ;;
|
|
if (!(newData))
|
|
return false;
|
|
;
|
|
for ( int i = 0;((i)<(lesser_lessthan_int_greaterthan__int_int(this->size, newSize) )); i++)
|
|
(newData)[i] = (this->data)[i];
|
|
;
|
|
delete_lessthan_double_greaterthan__double_P___int(this->data, 0) ;
|
|
this->data = newData;
|
|
this->available = newSize;
|
|
return true;
|
|
}
|
|
|
|
double vector_lessthan_double_greaterthan___at_int(vector_lessthan_double_greaterthan_* this, int index)
|
|
{
|
|
return vector_lessthan_double_greaterthan___get_int(this,index) ;
|
|
}
|
|
|
|
double vector_lessthan_double_greaterthan___get_int(vector_lessthan_double_greaterthan_* this, int index)
|
|
{
|
|
if (((((index)<(0)))||(((index)>=(this->size)))))
|
|
{
|
|
return (this->data)[0];
|
|
};
|
|
;
|
|
return (this->data)[index];
|
|
}
|
|
|
|
double* vector_lessthan_double_greaterthan___getBackingMemory(vector_lessthan_double_greaterthan_* this)
|
|
{
|
|
return this->data;
|
|
}
|
|
|
|
void vector_lessthan_double_greaterthan___set_int_double(vector_lessthan_double_greaterthan_* this, int index, double dataIn)
|
|
{
|
|
if (((((index)<(0)))||(((index)>=(this->size)))))
|
|
return;
|
|
;
|
|
(this->data)[index] = dataIn;
|
|
}
|
|
|
|
void vector_lessthan_double_greaterthan___addEnd_double(vector_lessthan_double_greaterthan_* this, double dataIn)
|
|
{
|
|
this->size++;
|
|
if (((this->size)>=(this->available)))
|
|
vector_lessthan_double_greaterthan___resize_int(this,((this->size)*(2))) ;
|
|
;
|
|
(this->data)[((this->size)-(1))] = dataIn;
|
|
}
|
|
/* Done with vector<double> */
|