int main (void) {
int** layer1 = makeArray();
int** layer2 = makeArray();
int** temp;
srand(time(NULL));
populate (layer1);
prettyPrint (layer1);
while (1) {
struct timeval bad;
bad.tv_sec = 0;
bad.tv_usec = 10000;
select (0, NULL, NULL, NULL, &bad);
iterate (layer1, layer2);
prettyPrint (layer2);
temp = layer1;
layer1 = layer2;
layer2 = temp;
}
return 0;
}
void drawString(drawing* d, char* s, int boardX, int boardY){
int length = strlen(s);
char c;
d->canvas = makeArray(CHRCX,(CHRCY+1)*length);
d->x = boardX;
d->y = boardY;
d->width = (CHRCX+1)*length;
d->height = CHRCY;
for(int i=0; i<length; i++){
c = s[i];
if(c>='0' && c<='9'){
drawChrc_numb(d, c-48, i*(CHRCX+1));
}
else if(c>='A' && c<='Z'){
drawChrc_ucas(d, c-65, i*(CHRCX+1));
}
else if(c>='a' && c<='z'){
drawChrc_lcas(d, c-97, i*(CHRCX+1));
}
else if(c==' '){
drawChrc_spce(d, i*(CHRCX+1));
}
}
}
int add(char *username, char *password, char *type)
{
makeArray();
for(i = 0; i < numberOfLines; i++)
{
char tempName[50];
strcpy(tempName, username);
strcat(tempName, ",");
if(strncmp(array[i], tempName, strlen(tempName)) == 0) return EXIT_FAILURE;
}
strcpy(array[numberOfLines], username); //we add username to the array
strcat(array[numberOfLines], ", "); //we remove the ',' between each string
strcat(array[numberOfLines], password);
strcat(array[numberOfLines], ", ");
strcat(array[numberOfLines], type);
encrypt(array);
out=fopen("password.csv", "wt");
for (i=0; i<numberOfLines; i++)
{
fprintf(out, "%s\n", array[i]);
}
fclose(out);
return EXIT_SUCCESS;
}
/*
Shifts the content of the rectangle into a parallelogram
@param: drawing* d
*/
void shearHrz(drawing* d, int factor){
bool** temp = makeArray(d->width + abs(factor)*(d->height-1), d->height);
if (factor > 0){
for(int i = 0; i < d->height; i++){
for(int j = 0; j < d->width; j++){
temp[i][j+((d->height-i-1)*factor)] = d->canvas[i][j];
}
}
}
else{
factor *= -1;
for(int i = 0; i < d->height; i++){
for(int j = 0; j < d->width; j++){
temp[i][j+(i*factor)] = d->canvas[i][j];
}
}
}
bool** clone = d->canvas;
d->canvas = temp;
free(clone);
d->width += factor*(d->height-1);
}
int main() {
std::vector<PID::Produce> product_list = makeArray();
sf::Text text;
text.setString(
"Bar Code: " + product_list[0].getBarcode() + "\n" + "Name: " +
product_list[0].getName() + "\n" + "Store Date: " +
std::to_string(product_list.at(0).getStoredDate().getMonth()) + "/" +
std::to_string(product_list.at(0).getStoredDate().getDay()) + "/" +
std::to_string(product_list.at(0).getStoredDate().getYear() + 1900) +
"\n");
sf::Font font;
font.loadFromFile("RobotoCondensed-Light.ttf");
text.setFont(font);
text.setPosition(680, 100);
sf::Texture texture;
texture.loadFromFile("resources/1.jpg");
sf::Sprite sprite;
sprite.setTexture(texture);
sf::RenderWindow window(sf::VideoMode(1280, 720), "FridgeFriend");
while (window.isOpen()) {
sf::Event event;
while (window.pollEvent(event)) {
if (event.type == sf::Event::Closed)
window.close();
}
window.clear();
window.draw(sprite);
window.draw(text);
window.display();
}
return 0;
}
Array::operator const Poco::Dynamic::Array& () const
{
if (!_pArray)
{
ValueVec::const_iterator it = _values.begin();
ValueVec::const_iterator end = _values.end();
_pArray = new Poco::Dynamic::Array;
int index = 0;
for (; it != end; ++it, ++index)
{
if (isObject(it))
{
_pArray->insert(_pArray->end(), Poco::JSON::Object::makeStruct(getObject(index)));
}
else if (isArray(it))
{
_pArray->insert(_pArray->end(), makeArray(getArray(index)));
}
else
{
_pArray->insert(_pArray->end(), *it);
}
}
}
return *_pArray;
}
void IniSetting::ParserCallback::onPopEntry(
const std::string &key,
const std::string &value,
const std::string &offset,
void *arg) {
Variant *arr = (Variant*)arg;
forceToArray(*arr);
bool oEmpty = offset.empty();
// Substitution copy or symlink
// Offset come in like: hhvm.a.b\0c\0@
// Check for `\0` because it is possible, although unlikely, to have
// something like hhvm.a.b[c@]. Thus we wouldn't want to make a substitution.
if (!oEmpty && (offset.size() == 1 || offset[offset.size() - 2] == '\0') &&
(offset.back() == '@' || offset.back() == ':')) {
makeSettingSub(key, offset, value, *arr);
} else { // Normal array value
String skey(key);
auto& hash = arr->toArrRef().lvalAt(skey);
forceToArray(hash);
if (!oEmpty) { // a[b]
makeArray(hash, offset, value);
} else { // a[]
hash.toArrRef().append(value);
}
}
}
Poco::Dynamic::Array Array::makeArray(const JSON::Array::Ptr& arr)
{
Poco::Dynamic::Array vec;
JSON::Array::ConstIterator it = arr->begin();
JSON::Array::ConstIterator end = arr->end();
int index = 0;
for (; it != end; ++it, ++index)
{
if (arr->isObject(it))
{
Object::Ptr pObj = arr->getObject(index);
DynamicStruct str = Poco::JSON::Object::makeStruct(pObj);
vec.insert(vec.end(), str);
}
else if (arr->isArray(it))
{
Array::Ptr pArr = arr->getArray(index);
std::vector<Poco::Dynamic::Var> v = makeArray(pArr);
vec.insert(vec.end(), v);
}
else
vec.insert(vec.end(), *it);
}
return vec;
}
void IniSetting::SystemParserCallback::onPopEntry(const std::string& key,
const std::string& value,
const std::string& offset,
void* arg) {
assert(!key.empty());
if (IniSetting::s_config_is_a_constant) {
IniSetting::config_names_that_use_constants.insert(key);
IniSetting::s_config_is_a_constant = false;
}
auto& arr = *(IniSetting::Map*)arg;
auto* ptr = arr.get_ptr(key);
if (!ptr || !ptr->isObject()) {
arr[key] = IniSetting::Map::object;
ptr = arr.get_ptr(key);
}
if (!offset.empty()) {
makeArray(*ptr, offset, value);
} else {
// Find the highest index
auto max = 0;
for (auto &a : ptr->keys()) {
try {
if (a.asInt() >= max) {
max = a.asInt() + 1;
}
} catch (std::range_error const& e) { /* not an int */ }
}
(*ptr)[std::to_string(max)] = value;
}
}
/*
This function adds d2 to the left of d1. This new drawing will be returned.
THIS FUNCTION ONLY WORKS WHEN THE HEIGHTS OF BOTH DRAWINGS IS THE SAME!!!
@param: drawing* d1, drawing* d2
two drawings which will be added together
@return: final drawing
*/
drawing* addDrawing(drawing* d1, drawing* d2){
drawing* finalD = (drawing*)malloc(sizeof(drawing));
finalD->x = d1->x;//sets the location
finalD->y = d1->y;
finalD->width = d1->width + d2->width;//sets the dimensions
finalD->height = d1->height;
finalD->canvas = makeArray(finalD->width, finalD->height);
for(int i = 0; i < d1->height; i++){//inputs the contents of d1 into the canvas
for(int j = 0; j < d1->width; j++){
finalD->canvas[i][j]= d1->canvas[i][j];
}
}
for(int i = 0; i < d1->height; i++){//inputs the contents of d2 into the canvas
for(int j = d1->width; j < finalD->width; j++){
finalD->canvas[i][j]= d2->canvas[i][j-d1->width];
}
}
return finalD;
}
Matrix makeMatrix(int rows, int cols, float v=0){
Matrix matrix;
for(int i = 0; i < rows; i++){
Array a = makeArray(cols, v);
matrix.push_back(a);
}
return matrix;
}
void DataStruct::expandIndirection( bool arrayind)
{
if (m_size < 0 && m_description && m_data.ref == 0)
{
initStructElements();
if (arrayind) makeArray();
}
}
int main()
{
/*#TS*/
makeView("mainView", "wholeGraph","Higraph.PDV", "PlacedNode");
setTitle("mainView", "Matrices PDV");
setDefaultNodeValueShow(true, CENTER);
setDefaultNodeValueColor(MARKER_RED);
setDefaultNodeShape(RECTANGLE);
//ScriptManager::relay("HigraphManager", "setDefaultZoneColor", BLUE);
ScriptManager::relay("HigraphManager", "setDefaultNodeFillColor", WHITE);
ScriptManager::relay("HigraphManager", "setDefaultNodeValueShow", true, CENTER);
ScriptManager::relay("HigraphManager", "setDefaultNodeValueColor", BLACK);
ScriptManager::relay("HigraphManager", "setDefaultNodeNameShow", true, WEST);
ScriptManager::relay("HigraphManager", "setDefaultNodeNameColor", MAGENTA);
ScriptManager::relay("HigraphManager", "setDefaultNodeShape", RECTANGLE);
ScriptManager::relay("HigraphManager","setDefaultNodeSize", 40, 40);
/*#/TS*/
const int rows = 2;
const int cols = 3;
int val = 10;/*#TS*/ setupval(val);
/*#/TS*/
int matrix[rows*cols];
/*#TS*/makeArray(matrix,(rows*cols),true,"matrix[]");/*#/TS*/
int i,j;/*#TS*//*nodes for i & j*/setup_i_j(i,j);/*#/TS*/
/*#TS*/int **mat = new int*[rows];
for(int k=0;k<rows;k++)
mat[k]=new int[cols];
makeMatrix(mat,rows,cols,true,"Theoretical representation");/*#/TS*/
for(i = 0; i < rows; i++)
{
for(j = 0; j < cols; j++)
{ /*#TS*/ScriptManager::relay("HigraphManager","setNodeFillColor", mat[i][j], YELLOW);
ScriptManager::relay("HigraphManager","setNodeFillColor", matrix[(i*cols)+j], YELLOW);/*#/TS*/
/*#TS*/ mat[i][j]=val;/*#/TS*/
matrix[(i*cols)+j]=val++;
/*#TS*/ScriptManager::relay("HigraphManager","setNodeFillColor", mat[i][j], WHITE);
ScriptManager::relay("HigraphManager","setNodeFillColor", matrix[(i*cols)+j], WHITE);/*#/TS*/
}
}
//Call module to add 1 to each element of matrix
add1(matrix, rows, cols);
//See that the values of the original matrix have changed
/*#TS*/
//ScriptManager::relay("HigraphManager","setNodeNameLabel",matrix,"matrix[]");
/*#/TS*/
return 0;
}
int main (){
//std::tr1::array<int,3> Integer = makeArray(2,3,4);
std::tr1::array<Obj,3> Objs = makeArray(Obj(1), Obj(2), Obj(3));
std::cout << "1:" << Objs[0].val << " 2:" << Objs[1].val << " 3:" << Objs[2].val << std::endl;
return 0;
}
int main(int argc, char **argv) {
int c;
char *file_name = NULL;
int number_of_words = 0;
FILE *input_file;
while ( (c = getopt(argc, argv, "i:n:")) != -1) {
switch (c) {
case 'i':
file_name = optarg;
break;
case 'n':
number_of_words = atoi(optarg);
break;
}
}
if (file_name == NULL || number_of_words == 0) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
input_file = fopen(file_name, "r");
if (input_file == NULL) {
fprintf(stderr, "Cannot open file %s\n", file_name);
exit(EXIT_FAILURE);
}
while(!feof(input_file)) {
char word[64];
fscanf(input_file, "%s\n", word);
toLower(word);
printf("%s\n", word);
struct Entry *existing = search(word);
if (existing != NULL) {
++existing->count;
} else {
struct Entry *tail = findTail();
struct Entry *entry = malloc(sizeof(struct Entry));
strcpy(entry->word, word);
entry->count = 1;
tail->next = entry;
}
}
int entry_count = count();
printf("Number of element is the list is %d\n", entry_count);
//showAll();
struct Entry asArray[entry_count];
makeArray(asArray);
qsort(asArray, entry_count, sizeof(struct Entry), cmpfunc);
for(int i=0 ; i < entry_count ; i++) {
struct Entry e = asArray[i];
printf("Word: %s Count: %d\n", e.word, e.count);
}
return EXIT_SUCCESS;
}
int main() {
int tstep;
char time_str[34];
time_t t0;
// Set the parameters
int Nx, Ny, Nz, TMAX;
Nx = 200;
Ny = 200;
Nz = 208;
TMAX = 100;
// Allocate host memory
float ***Ex, ***Ey, ***Ez;
float ***Hx, ***Hy, ***Hz;
float ***CEx, ***CEy, ***CEz;
Ex = makeArray(Nx, Ny, Nz);
Ey = makeArray(Nx, Ny, Nz);
Ez = makeArray(Nx, Ny, Nz);
Hx = makeArray(Nx, Ny, Nz);
Hy = makeArray(Nx, Ny, Nz);
Hz = makeArray(Nx, Ny, Nz);
CEx = makeArray(Nx, Ny, Nz);
CEy = makeArray(Nx, Ny, Nz);
CEz = makeArray(Nx, Ny, Nz);
// Geometry
set_geometry(Nx, Ny, Nz, CEx, CEy, CEz);
// Update on the CPU
t0 = time(0);
for ( tstep=1; tstep<=TMAX; tstep++) {
updateE(Nx, Ny, Nz, Ex, Ey, Ez, Hx, Hy, Hz, CEx, CEy, CEz);
updateSrc(Nx, Ny, Nz, Ex, tstep);
updateH(Nx, Ny, Nz, Ex, Ey, Ez, Hx, Hy, Hz);
if ( tstep/100*100 == tstep ) {
//dumpToH5(Nx, Ny, Nz, Nx/2, 0, 0, Nx/2, Ny-1, Nz-1, Ex, "cpu_png/Ex-%05d.h5", tstep);
//exec("h5topng -ZM0.1 -x0 -S4 -c /usr/share/h5utils/colormaps/dkbluered cpu_png/Ex-%05d.h5", tstep);
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
}
updateTimer(t0, tstep, time_str);
printf("tstep=%d\t%s\n", tstep, time_str);
}
int main()
{
int* firstArray = makeArray(); //create array
for (int n = 0; n < 8; n++) //display contents of array
{
cout << firstArray[n] << " ";
}
cout << endl;
cout << "Smallest number in array: " << smallestNumber(firstArray, 8) << endl; //display smallest number in array
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int nc;
double* data;
/* Function signature for the function handle */
double* (*fun)(double*);
/* Get the actual function handle back */
fun = (double* (*)(double*)) *((mwSize*) mxGetData(prhs[0]));
/* Call the C function through the handle and set the data*/
data = fun(mxGetPr(prhs[2]));
/* how much data to expect */
nc = (int) mxGetScalar(prhs[1]);
plhs[0] = makeArray(data,1,nc);
}
int main( int argc, void ** argv ) {
int array_count = 20;
int *array = makeArray( array_count );
if( !array )
return 0;
quicksort( array, array_count );
mergesort( array, array_count );
heapsort( array, array_count );
free( array );
return 0;
}
void
hashMapResize(Thread* t, object map, uint32_t (*hash)(Thread*, object),
unsigned size)
{
PROTECT(t, map);
object newArray = 0;
if (size) {
object oldArray = hashMapArray(t, map);
PROTECT(t, oldArray);
unsigned newLength = nextPowerOfTwo(size);
if (oldArray and arrayLength(t, oldArray) == newLength) {
return;
}
newArray = makeArray(t, newLength);
if (oldArray != hashMapArray(t, map)) {
// a resize was performed during a GC via the makeArray call
// above; nothing left to do
return;
}
if (oldArray) {
bool weak = objectClass(t, map) == type(t, Machine::WeakHashMapType);
for (unsigned i = 0; i < arrayLength(t, oldArray); ++i) {
object next;
for (object p = arrayBody(t, oldArray, i); p; p = next) {
next = tripleThird(t, p);
object k = tripleFirst(t, p);
if (weak) {
k = jreferenceTarget(t, k);
if (k == 0) {
continue;
}
}
unsigned index = hash(t, k) & (newLength - 1);
set(t, p, TripleThird, arrayBody(t, newArray, index));
set(t, newArray, ArrayBody + (index * BytesPerWord), p);
}
}
}
}
set(t, map, HashMapArray, newArray);
}
void IniSetting::ParserCallback::onPopEntry(
const std::string &key, const std::string &value, const std::string &offset,
void *arg) {
Variant *arr = (Variant*)arg;
Variant &hash = arr->lvalAt(String(key));
if (!hash.isArray()) {
hash = Array::Create();
}
if (!offset.empty()) {
makeArray(hash, offset, value);
} else {
hash.append(value);
}
}
object
growArray(Thread* t, object array)
{
PROTECT(t, array);
object newArray = makeArray
(t, array == 0 ? 16 : (arrayLength(t, array) * 2));
if (array) {
memcpy(&arrayBody(t, newArray, 0), &arrayBody(t, array, 0),
arrayLength(t, array));
}
return newArray;
}
void IniSetting::ParserCallback::onPopEntry(
const std::string &key,
const std::string &value,
const std::string &offset,
void *arg) {
Variant *arr = (Variant*)arg;
forceToArray(*arr);
auto& hash = arr->toArrRef().lvalAt(String(key));
forceToArray(hash);
if (!offset.empty()) {
makeArray(hash, offset, value);
} else {
hash.toArrRef().append(value);
}
}
//This is where the fun part is...
char * sum(char *val0, char *val1) {
int size;
//getting the sizes of the passed char *str
//so that we can find the largest one
//and also because C doesn't have anykind of .length method
//and sizeof returns the sizeof a pointer
//so we have to explicitly keep track of size
int val0Size = getSize(val0);
int val1Size = getSize(val1);
//Makin' sure we've got a big enough array for the whole number.
if (val0Size > val1Size) {
size = val0Size;
} else if (val1Size > val0Size) {
size = val1Size;
} else {
size = val1Size;
}
//account for an extra zero at the beginning
char *numArr = makeArray(val0, size);
char *valArr = makeArray(val1, size);
int i = size;
for (; i >= 0; i--) {
int numArrTmp = toInt(numArr[i]);
int valArrTmp = toInt(valArr[i]);
int tmp = numArrTmp + valArrTmp;
//if tmp >= 10 we need to carry a 1
if (tmp >= 10) {
numArr = addTen(numArr, i, tmp);
//otherwise we don't
} else {
numArr[i] = toChar(tmp);
}
}
free(valArr);
return endCalc(numArr);
}
/*
Rotates the content counter clockwise
@param: drawing* d
*/
void rotateCcw(drawing* d){
int max = (d->height>d->width ? d->height:d->width);
bool** temp = makeArray(d->height, d->width);//switches width and height when mallocing
for(int i = 0; i < max; i++){
for(int j = 0; j < max; j++){
temp[j][i]=d->canvas[i][j];
}
}
bool** clone = d->canvas;
d->canvas = temp;
free(clone);
int t = d->width;
d->width = d->height;
d->height = t;
mirrorVrt(d);
}
/*
Rotates the content clockwise
@param: drawing* d
*/
void rotateCw(drawing* d){
int max = (d->height>d->width ? d->height:d->width);//which is larger? height or width?
bool** temp = makeArray(d->height, d->width);//switches width and height when mallocing
for(int i = 0; i < max; i++){//replaces the columns with rows
for(int j = 0; j < max; j++){
temp[j][i]=d->canvas[i][j];
}
}
bool** clone = d->canvas;// d is now this new drawing
d->canvas = temp;
free(clone);
int t = d->width;//fixes dimensions
d->width = d->height;
d->height = t;
mirrorHrz(d);//this makes it seem as though it is roatated clockwise
}
/*
Stretches Vertically the content of the drawing by a factor
@param: drawing* d
*/
void scaleVrt(drawing* d, int factor){
d->height *= factor;
bool** temp = makeArray(d->width, d->height);
for(int i=0;i<d->height;i++){
for(int j=0;j<d->width;j++){
temp[factor*i][j] = d->canvas[i][j];
}
}
for(int i=0;i<d->height*factor;i++){
for(int j=0;j<d->width;j++){
temp[i][j]=temp[(i/factor)*factor][j];
}
}
bool** clone = d->canvas;
d->canvas = temp;
free(clone);
}
/*
Stretches Horizontally the content of the drawing by a factor
@param: drawing* d
*/
void scaleHrz(drawing* d, int factor){
d->width *= factor;//fixes dimensions
bool** temp = makeArray(d->width,d->height );
for(int i=0;i<d->height;i++){
for(int j=0;j<d->width;j++){
temp[i][factor*j]=d->canvas[i][j];//this stretches the drawing, but it looks empty
}
}
for(int i=0;i<d->height;i++){
for(int j=0;j<d->width*factor;j++){
temp[i][j]=temp[i][(j/factor)*factor];//this fill the empty gaps
}
}
bool** clone = d->canvas;//d is now this new drawing
d->canvas = temp;
free(clone);
}
void drawChrc(drawing* d, char c, int boardX, int boardY){
d->canvas = makeArray(CHRCX, CHRCY);
d->x = boardX;
d->y = boardY;
d->width = CHRCX;
d->height = CHRCY;
if(c>='0' && c<='9'){
drawChrc_numb(d, c-48, 0);
}
else if(c>='A' && c<='Z'){
drawChrc_ucas(d, c-65, 0);
}
else if(c>='a' && c<='z'){
drawChrc_lcas(d, c-97, 0);
}
else if(c==' '){
drawChrc_spce(d, 0);
}
}
void IniSetting::SystemParserCallback::onPopEntry(
const std::string &key, const std::string &value, const std::string &offset,
void *arg) {
assert(!key.empty());
auto& arr = *(IniSetting::Map*)arg;
auto* ptr = arr.get_ptr(key);
if (!ptr || !ptr->isObject()) {
arr[key] = IniSetting::Map::object;
ptr = arr.get_ptr(key);
}
if (!offset.empty()) {
makeArray(*ptr, offset, value);
} else {
// Find the highest index
auto max = 0;
for (auto &a : ptr->keys()) {
if (a.isInt() && a >= max) {
max = a.asInt() + 1;
}
}
(*ptr)[std::to_string(max)] = value;
}
}
