int main()
{
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
int i,j,n;
int d1=0,d2=0,d3=0,p,min;
for(i=1;i<=11059200;i++){
d1+=720;d1%=11059200;
d2+=12;d2%=11059200;
d3+=1;
//printf("%d %d %d\n",d1,d2,d3);
min=figure(d1,d2);
p=figure(d2,d3);if(min>p) min=p;
p=figure(d1,d3);if(min>p) min=p;
//printf("%d\n",i);
for(j=0;j<=min;j++)
ans[j]++;
}
/*while(1){
scanf("%d",&n);
if(n==-1) return 0;
if(n>=120) printf("0.000\n");
else printf("%.3f\n",float(ans[n])/110592);
}*/
for(i=0;i<=3686400;i++)
printf("ans[%d]=%.3f\n",i,float(ans[i])/110592);
return 0;
}
void selectFigures(int pentamimo[][5][5]) // Зчитування фігур з файлу
{
OPENFILENAME ofn;
char szFileName[MAX_PATH] = "";
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFilter = (LPCWSTR)L"Text Files (*.txt)\0*.txt\0";
ofn.lpstrFile = (LPWSTR)szFileName;
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
ofn.lpstrDefExt = (LPCWSTR)L"txt";
if (GetOpenFileName(&ofn)) // Зчитування фігури
{
int n;
ifstream figure(ofn.lpstrFile);
for (int k = 0; k < 12; k++) {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
figure >> n;
pentamimo[k][i][j] = n;
}
}
}
figure.close();
}
//ShowField
//現在のマップ全体を出力する デバッグ用
void ShowField() {
int i,j;
for(i=0; i<100; i++) {
for(j=0; j<100; j++)
figure(field[i][j]);
printf("\n");
}
}
int main()
{
figure();
int n;
while(scanf("%d",&n))
{
if(n==0)return 0;
int ans=dp[53][n];
if(ans<n)ans=n;
printf("%d\n",ans);
}
return 0;
}
shared_ptr<Figure> CurveEditPart::createFigure()
{
shared_ptr< CurveFigure > figure( new CurveFigure());
figure->setStartPoint (curve_->getStartPoint());
figure->setEndPoint (curve_->getEndPoint());
figure->setStartControlPoint (curve_->getStartControlPoint());
figure->setEndControlPoint (curve_->getEndControlPoint());
figure->getStrokeStyle()->setColor (curve_->getLineColor());
figure->getStrokeStyle()->setLineWidth (curve_->getLineWidth());
figure->getStrokeStyle()->setLineDashStyle (curve_->getLineDashStyle());
figure->getStrokeStyle()->setLineDashStyleOffset (curve_->getLineDashStyleOffset());
return figure;
}
//output
//主人公周辺のマップを端末出力
void output() {
int center; //主人公位置のデータを保管
int i,j;
printf(" * * * * * * *\n");
printf(" * 座標 : x=%2d Y=%2d *\n",man.x,man.y);
printf(" * 表\示領域 : %2d×%2d * \n",DispAreax,DispAreay);
printf(" * * * * * * * \n\n");
center=field[man.x][man.y];
field[man.x][man.y]=9;
for(j=0; j<DispAreay; j++) {
for(i=0; i<DispAreax; i++) {
figure(field[man.x-radiusx+i][man.y-radiusy+j]);
}
printf("\n");
}
field[man.x][man.y]=center; //☆に置き換えたデータを下に戻す
}
int main(int argc, char *argv[]) {
glplot::imagesc c_image;
glplot::figure figure(c_image);
#if 1
while(1) {
double af_tmp[512][16];
for(int i = 0; i<512; i++) {
for(int j = 0; j<16; j++) {
af_tmp[i][j] = 512.0*sin(M_PI*2.0*i/512)/*+100.0*rand()/RAND_MAX*/; //sin(i);
}
}
//_c_plot.f_plot(af_tmp, 512);
c_image.f_plot((double*)af_tmp, 512, 16);
break;
}
#endif
return figure.f_wait();
}
//---------------------------------------------------------
void TestPoissonIPDG3D::Run()
//---------------------------------------------------------
{
umLOG(1, "TestPoissonIPDG3D::Run()\n");
double wt1=timer.read();
// Initialize solver and construct grid and metric
StartUp3D();
#if (0)
//-------------------------------------
// check the mesh
//-------------------------------------
Output_Mesh();
umLOG(1, "\n*** Exiting after writing mesh\n\n");
return;
#endif
// sparse operators
CSd A("OP"), M("MM");
// build 3D IPDG Poisson matrix (assuming all Dirichlet)
PoissonIPDG3D(A, M);
if (0) {
// NBN: experiment with diagonal strength
int Nz=0;
for (int j=0; j<A.n; ++j) {
for (int p = A.P[j]; p<A.P[j+1]; ++p) {
if (A.I[p] == j) {
A.X[p] += A.X[p]; // augment A(i,j)
}
}
}
}
if (0) {
umLOG(1, "Dumping file Afull.dat for Matlab\n");
umLOG(1, "A(%d,%d), nnz = %d\n", A.m,A.n, A.P[A.n]);
FILE* fp=fopen("Afull.dat", "w");
A.write_ML(fp);
fclose(fp);
umLOG(1, "exiting.\n");
return;
}
// iterative solver
CS_PCG it_sol;
try
{
// Note: operator A is symmetric, with only its
// lower triangule stored. We use this symmetry
// to accelerate operator A*x
int flag=sp_SYMMETRIC; flag|=sp_LOWER; flag|=sp_TRIANGULAR;
A.set_shape(flag);
// drop tolerance for cholinc
double droptol=1e-4;
// Note: ownership of A is transfered to solver object
it_sol.cholinc(A, droptol);
} catch(...) {
umLOG(1, "\nCaught exception from symbolic chol.\n");
}
DVec exact("exact"), f("f"), rhs("rhs"), u("u");
double t1=0.0,t2=0.0;
//-------------------------------------------------------
// set up boundary condition
//-------------------------------------------------------
DVec xbc = Fx(mapB), ybc = Fy(mapB), zbc = Fz(mapB);
DVec ubc(Nfp*Nfaces*K);
ubc(mapB) = sin(pi*xbc) * sin(pi*ybc) * sin(pi*zbc);
//-------------------------------------------------------
// form right hand side contribution from boundary condition
//-------------------------------------------------------
DMat Abc = PoissonIPDGbc3D(ubc);
//-------------------------------------------------------
// evaluate forcing function
//-------------------------------------------------------
exact = sin(pi*x).dm(sin(pi*y).dm(sin(pi*z)));
f = (-3.0*SQ(pi)) * exact;
//-------------------------------------------------------
// set up right hand side for variational Poisson equation
//-------------------------------------------------------
rhs = M*(-f) + (DVec&)(Abc);
//-------------------------------------------------------
// solve using pcg iterative solver
//-------------------------------------------------------
t1 = timer.read();
u = it_sol.solve(rhs, 1e-9, 30);
t2 = timer.read();
//-------------------------------------------------------
// compute nodal error
//-------------------------------------------------------
r = (u-exact);
m_maxAbsError = r.max_val_abs();
umLOG(1, " solve -- done. (%0.4lf sec)\n\n", t2-t1);
umLOG(1, " max error = %g\n\n", m_maxAbsError);
#if (0)
//#######################################################
// plot solution and error
figure(2);
subplot(1,3,2); PlotContour3D(2*N, u, linspace(-1, 1, 10)); title('numerical solution');
subplot(1,3,3); PlotContour3D(2*N, log10(eps+abs(u-exact)), linspace(-4, 0, 10));
title('numerical error');
//#######################################################
#endif
double wt2=timer.read();
umLOG(1, "TestPoissonIPDG3D::Run() complete\n");
umLOG(1, "total time = %0.4lf sec\n\n", wt2-wt1);
}
int main(int argc,char **argv)
{
progname = argv[0];
int do_bugs = 0;
int do_sequential = 0;
int do_reverse = 0;
int do_random_write_test = 0;
int do_random_read_test = 0;
int do_large_file = 0;
int do_maxsize_test = 0;
int random_repeat = 1;
int do_sparse_test = 0;
int do_all=0;
int do_image_test =1;
int ch;
const char *bigdir = getenv(AFFLIB_BIGTMP); // use by default
if(bigdir) tempdir = bigdir;
setvbuf(stdout,0,_IONBF,0);
//putenv(AFFLIB_CACHE_STATS"=1");
if(argc==1){
printf("running all tests with -a option (exception bigfile test)\n");
do_all = 1;
}
while ((ch = getopt(argc, argv, "b123456aBLd:h?f:e:c:TCp:rx:R:z:tn:D:S:")) != -1) {
switch(ch){
case 'D': af_trace = fopen(optarg,"w");break;
case 'R': readfile_test(optarg); break;
case 'b':
do_bugs = 1;
break;
case '1':
do_sequential = 1;
break;
case '2':
do_reverse = 1;
break;
case '3':
do_random_write_test = 1;
break;
case '4':
do_random_read_test = 1;
break;
case '5':
do_maxsize_test = 1;
break;
case '6': do_sparse_test = 1; break;
case 'l':
random_repeat = atoi(optarg);
break;
case 'B':
do_large_file = 1;
break;
case 'n': MAX_FMTS = atoi(optarg); break;
case 't': time_test(); break;
case 'L': opt_compression_type = AF_COMPRESSION_ALG_LZMA; break;
case 'T': lzma_test(); break;
case 'r': rsatest(); break;
case 'a':
do_all = 1;
break;
case 'z':
zap(optarg);break;
case 'd': tempdir = optarg; break;
case 'f': figure(optarg); break;
case 'e': opt_ext = optarg; break;
case 'c': compress(optarg); break;
case 'p': opt_protocol = optarg; break;
case 'x': xmltest(optarg);break;
case 'C': aestest(); break;
case 'i': do_image_test=1;break;
case 'S': split_raw_test(optarg);exit(0);
case 'h':
case '?':
default:
usage();
}
}
if(do_bugs || do_all) bugs_test();
if(do_sequential || do_all) sequential_test();
if(do_reverse || do_all ) reverse_test();
if(do_maxsize_test || do_all) maxsize_test();
if(do_sparse_test || do_all) sparse_test();
if(do_image_test || do_all) image_test();
for(int i=0;i<random_repeat;i++){
if(do_random_read_test || do_all) random_read_test(256*1024,rand() % 65536);
if(do_random_write_test || do_all) random_write_test();
}
if(do_large_file) large_file_test();
/* Now erase the files ... */
unlink("test_random.aff");
unlink("test_reverse.aff");
unlink("test_random_contents.aff");
unlink("test_sequential.aff");
unlink("bugs.aff");
unlink("test_random_contents.img");
unlink("sparse.aff");
return 0;
}
int main(int argc, char* argv[])
{
Handle<es::Context> nameSpace = System()->getRoot();
Handle<es::Stream> framebuffer(nameSpace->lookup("device/framebuffer"));
void* mapping = System()->map(0, framebuffer->getSize(),
es::CurrentProcess::PROT_READ | es::CurrentProcess::PROT_WRITE,
es::CurrentProcess::MAP_SHARED,
Handle<es::Pageable>(framebuffer), 0);
// Register canvas
cairo_surface_t* surface;
CanvasInfo canvasInfo;
canvasInfo.x = 0;
canvasInfo.y = 0;
canvasInfo.width = 1024;
canvasInfo.height = 768;
canvasInfo.format = CAIRO_FORMAT_ARGB32; // or CAIRO_FORMAT_RGB24
// surface = cairo_image_surface_create(canvasInfo.format, canvasInfo.width, canvasInfo.height);
surface = cairo_image_surface_create_for_data(
static_cast<u8*>(mapping), canvasInfo.format , canvasInfo.width, canvasInfo.height,
sizeof(u32) * canvasInfo.width);
Canvas* canvas = new Canvas(surface, canvasInfo.width, canvasInfo.height);
ASSERT(canvas);
Handle<es::Context> device = nameSpace->lookup("device");
device->bind("canvas", static_cast<es::CanvasRenderingContext2D*>(canvas));
ASSERT(nameSpace->lookup("device/canvas"));
esReport("start canvas.\n");
if (argc < 2)
{
figure(canvas);
// transform(canvas);
#ifndef __es__
esSleep(40000000);
#endif
}
else
{
// Create a child process.
Handle<es::Process> child = es::Process::createInstance();
TEST(child);
// Start the child process.
std::string param;
for (int i = 1; i < argc; ++i) {
param += argv[i];
param += " ";
}
Handle<es::File> file = nameSpace->lookup(argv[1]);
if (file)
{
child->setRoot(nameSpace);
child->setCurrent(nameSpace);
child->start(file, param.c_str());
child->wait();
}
}
System()->unmap(mapping, framebuffer->getSize());
canvas->release();
esReport("quit canvas.\n");
}
