MainWindow::MainWindow(QWidget *parent): QMainWindow(parent), ui(new Ui::MainWindow)
{
ui->setupUi(this);
/*kozepre teszi a nyito kepernyot*/
QRect available_geom = QDesktopWidget().availableGeometry();
QRect current_geom = frameGeometry();
setGeometry(available_geom.width() / 2 - current_geom.width() / 2,
available_geom.height() / 2 - current_geom.height() / 2,
current_geom.width(),
current_geom.height());
/********************************/
connect(ui->actionExit, SIGNAL(triggered()), this, SLOT(close()));
connect(ui->actionSave, SIGNAL(triggered()), this, SLOT(MenTXT()));
connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(showAbout()));
connect(ui->actionBinom, SIGNAL(triggered()), this, SLOT(binom()) );
connect(ui->actionHelp, SIGNAL(triggered()), this, SLOT(showHelp()));
connect(ui->actionPrint, SIGNAL(triggered()), this, SLOT(printIt()));
ui->mainToolBar->addAction(ui->actionSave);
ui->mainToolBar->addAction(ui->actionPrint);
ui->mainToolBar->addSeparator();
ui->mainToolBar->addAction(ui->actionBinom);
ui->mainToolBar->addSeparator();
ui->mainToolBar->addAction(ui->actionHelp);
verzio = "2010-03-03";
settingClear();
}
void LongestDesend(int *array,int len,int &start,int &end)
{
if (array==NULL || len<1)
return;
int low=0;
int high=0;
int LEN=0;
while (high<len)
{
if (array[high+1]<array[high])
{
high++;
}
else
{
printIt(array,low,high);
if (LEN<(high-low+1))
{
LEN=(high-low+1);
start=low;
end=high;
}
high++;
low=high;
}
}
}
void TopLevel::print(){
if(!thispage || !firstpage) {
return KMessageBox::sorry(this, i18n("There is no document active."));
}
int pages, currentpage;
loadAllPages(pages, currentpage);
KPrinter printer(true, QPrinter::HighResolution);
printer.setFullPage( true );
printer.setUsePrinterResolution( true );
printer.setCreator( i18n("KFax") + " " KFAXVERSION );
printer.setDocName( QString("%1 - %2").arg(firstpage->name).arg(i18n("KFax")));
printer.setDocFileName( firstpage->name );
printer.setPageSelection( KPrinter::ApplicationSide );
printer.setMinMax( 1, pages );
printer.setCurrentPage( currentpage );
printer.addDialogPage(new KFAXPrintSettings());
if ( !printer.setup( this ) )
return;
QPainter painter;
painter.begin( &printer );
printIt(printer, painter);
painter.end();
}
// Main function
int main(int argc, char *argv[]){
char *line;
char *address;
char pattern[] = "GCAG";
getString(&line);
address = findMatch(line, pattern);
printIt(address);
if (address != NULL)
getIndex(line, address);
}
void printHelp (CoinParamVec ¶mVec, int firstParam, int lastParam,
std::string prefix,
bool shortHelp, bool longHelp, bool hidden)
{ bool noHelp = !(shortHelp || longHelp) ;
int i ;
int pfxLen = static_cast<int>(prefix.length()) ;
bool printed = false ;
if (noHelp)
{ int lineLen = 0 ;
for (i = firstParam ; i <= lastParam ; i++)
{ CoinParam *param = paramVec[i] ;
if (param == 0) continue ;
if (param->display() || hidden)
{ std::string nme = param->matchName() ;
int len = static_cast<int>(nme.length()) ;
if (!printed)
{ std::cout << std::endl << prefix ;
lineLen += pfxLen ;
printed = true ; }
lineLen += 2+len ;
if (lineLen > 80)
{ std::cout << std::endl << prefix ;
lineLen = pfxLen+2+len ; }
std::cout << " " << nme ; } }
if (printed)
{ std::cout << std::endl ; } }
else
if (shortHelp)
{ for (i = firstParam ; i <= lastParam ; i++)
{ CoinParam *param = paramVec[i] ;
if (param == 0) continue ;
if (param->display() || hidden)
{ std::cout << std::endl << prefix ;
std::cout << param->matchName() ;
std::cout << ": " ;
std::cout << param->shortHelp() ; } }
std::cout << std::endl ; }
else
if (longHelp)
{ for (i = firstParam ; i <= lastParam ; i++)
{ CoinParam *param = paramVec[i] ;
if (param == 0) continue ;
if (param->display() || hidden)
{ std::cout << std::endl << prefix ;
std::cout << "Command: " << param->matchName() ;
std::cout << std::endl << prefix ;
std::cout << "---- description" << std::endl ;
printIt(param->longHelp().c_str()) ;
std::cout << prefix << "----" << std::endl ; } } }
std::cout << std::endl ;
return ; }
char printList(list *lst,void (printIt)(void *dt))
{
node *tracker;
if(lst==NULL)
return '1';
else if (lst->front==NULL || lst->back==NULL)
return '2';
else
{
tracker=lst->front;
while(tracker != NULL )
{
printIt(tracker->data);
tracker=tracker->next;
}
}
return '0';
}
int main(
int argc,
char **argv
)
{
int i;
debugio_init();
#if 1
uart_1_puts( "what is up\n" );
_delay_ms( 100.0 );
#endif
/* for printk and printu0 (-R/-W IO and uart0 IO) */
for ( i=1 ; i<13 ; i++ )
printIt( i%8 );
printk( "Sending exit request\n" );
printu0( "E\n" );
while(1) ; /* kill time until forced to exit */
return 0;
}
void main (void) {
printIt();
}
int main()
{
printIt(192.0f); // CHECK: 0xffffff40
printIt(-189.0f); // CHECK: 0x000000bd
}
int Solver::solve(
Complex<float>* &x_in, // buffer holding the solutions
Complex<float>* &A_in, // buffer holding matrices
Complex<float>* &b_in, // buffer holding the left sides
int &N, // size of each linear system
int &batch, // number of linear systems
bool &x_on_gpu, // true if x should remain on the gpu
bool &A_on_gpu, // true if R is already on the gpu
bool &b_on_gpu // true if b is already on the gpu
)
{
if (N < 1 || N > 72) {
printIt("Error in Solver: Min N is 1 and max N is 72.\n");
return cudaErrorLaunchFailure;
}
if (batch < 1) {
printIt("Erroro in Solver: batch must be larger than 0.\n");
return cudaErrorLaunchFailure;
}
cuComplex *x = (cuComplex*)x_in;
cuComplex *A = (cuComplex*)A_in;
cuComplex *b = (cuComplex*)b_in;
// TODO: Call zfsolve_batch in solve.h
cudaError e;
cuComplex* x_gpu;
cuComplex* A_gpu;
cuComplex* b_gpu;
size_t x_buffer_size = N*batch*sizeof(cuComplex);
size_t A_buffer_size = N*N*batch*sizeof(cuComplex);
size_t b_buffer_size = N*batch*sizeof(cuComplex);
if (x_on_gpu) {
x_gpu = x;
} else { // TODO: make a function for this...
e = cudaMalloc<cuComplex>(&x_gpu, x_buffer_size);
if (e != cudaSuccess) return e;
e = cudaMemcpy((void*)x_gpu, (void*)x, x_buffer_size, cudaMemcpyHostToDevice);
if (e != cudaSuccess) return e;
}
if (A_on_gpu) {
A_gpu = (cuComplex*) A; // not good, but what to do?
} else {
e = cudaMalloc<cuComplex>(&A_gpu, A_buffer_size);
if (e != cudaSuccess) return e;
e = cudaMemcpy((void*)A_gpu, (void*)A, A_buffer_size, cudaMemcpyHostToDevice);
if (e != cudaSuccess) return e;
}
if (b_on_gpu) {
b_gpu = (cuComplex*) b;
} else {
e = cudaMalloc<cuComplex>(&b_gpu, b_buffer_size);
if (e != cudaSuccess) return e;
e = cudaMemcpy((void*)b_gpu, (void*)b, b_buffer_size, cudaMemcpyHostToDevice);
if (e != cudaSuccess) return e;
}
// TODO:
// For small matrices one should use a kernel evaluating the invers (one thread per matrix)
// There is one such kernel for 3x3 in the RealTimeCapon folder, it should be possible to make kernels for 4x4 and 5x5 as well.
// Tip from Nvidia: up to 10x10 it should be faster to go with a 1-matrix-per-thread appraoch.
// This seems to be done in zfsolve_batch. There is different kernels beeing called depending on N.
if (N == 1) {
e = (cudaError) solve1x1(x_gpu, A_gpu, b_gpu, batch);
} else if (N == 3 && this->solverType == Solver::DIRECT) {
e = (cudaError) solve3x3(x_gpu, A_gpu, b_gpu, batch);
} else {
e = (cudaError) zfsolve_batch(A_gpu, b_gpu, x_gpu, N, batch);
}
if (e != cudaSuccess) return e; // TODO: What about allocated gpu memory if kernel fail?
if (!x_on_gpu) {
e = cudaMemcpy((void*)x, (void*)x_gpu, x_buffer_size, cudaMemcpyDeviceToHost);
if (e != cudaSuccess) return e;
e = cudaFree((void*)x_gpu);
if (e != cudaSuccess) return e;
}
if (!A_on_gpu) {
e = cudaFree((void*)A_gpu);
if (e != cudaSuccess) return e;
}
if (!b_on_gpu) {
e = cudaFree((void*)b_gpu);
if (e != cudaSuccess) return e;
}
return e;
}
