void solve() {
scanf("%d%d%d%d", &N, &P, &A, &B);
double p1 = 2.0 / ((double)N * N), p2 = (double)(N - 2) / N;
double rez[2][2], mat[2][2];
rez[0][0] = 1; rez[0][1] = 0;
rez[1][0] = 0; rez[1][1] = 1;
mat[0][0] = p1 + p2; mat[0][1] = p1 * (N - 1);
mat[1][0] = p1; mat[1][1] = p1 * (N - 1) + p2;
while (P) {
if (P & 1)
inm(rez, rez, mat);
inm(mat, mat, mat);
P >>= 1;
}
double ap = rez[0][0], bp = rez[1][0];
if (A == B)
printf("%.9lf\n", ap);
else
printf("%.9lf\n", bp);
}
int main()
{
int choice;
do {
printf("<<<<<<<<<<<<<<<< MENIU >>>>>>>>>>>>>>>>>> \n");
printf("1. Tabla inmultirii\n");
printf("2. Numele tau \n");
printf("3. Parole si salvare\n");
printf("4.\n");
printf("5. Iesire\n");
scanf("%d",&choice);
switch(choice)
{
case 1: inm();
break;
case 2: nume();
break;
default:
printf("Goodbye my friend! \n");
break;
}
} while (choice != 5);
return 0;
}
CORBA::Object_ptr TAO::Object_Group_Creator::create_infrastructure_managed_group (
const char * type_id)
{
CORBA::Object_var group = CORBA::Object::_nil ();
if (this->have_replication_manager_)
{
// set typeid properties
PortableGroup::Properties properties (1);
properties.length (3);
properties[0].nam.length (1);
properties[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE;
properties[0].val <<= PortableGroup::MEMB_INF_CTRL;
PortableGroup::InitialNumberMembersValue inm(2);
properties[1].nam.length (1);
properties[1].nam[0].id = PortableGroup::PG_INITIAL_NUMBER_MEMBERS;
properties[1].val <<= inm;
PortableGroup::MinimumNumberMembersValue mnm(1);
properties[2].nam.length (1);
properties[2].nam[0].id = PortableGroup::PG_MINIMUM_NUMBER_MEMBERS;
properties[2].val <<= mnm;
this->replication_manager_->set_type_properties (
type_id,
properties);
::PortableGroup::GenericFactory::FactoryCreationId_var creation_id;
PortableGroup::Criteria criteria (1);
criteria.length (1);
criteria[0].nam.length (1);
criteria[0].nam[0].id = PortableGroup::PG_MEMBERSHIP_STYLE;
criteria[0].val <<= PortableGroup::MEMB_APP_CTRL;
group = this->replication_manager_->create_object (
type_id,
criteria,
creation_id
);
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("%T %n (%P|%t): Object_Group_Creator: infrastructure managed group requires Replication Manager\n")
));
}
return group._retn ();
}
/*
* ATIMach64Sync --
*
* This is called to wait for the draw engine to become idle.
*/
void
ATIMach64Sync
(
ScrnInfoPtr pScreenInfo
)
{
ATIPtr pATI = ATIPTR(pScreenInfo);
#ifdef XF86DRI_DEVEL
if ( pATI->directRenderingEnabled && pATI->NeedDRISync )
{
ATIHWPtr pATIHW = &pATI->NewHW;
if (pATI->OptionMMIOCache) {
/* "Invalidate" the MMIO cache so the cache slots get updated */
UncacheRegister(SRC_CNTL);
UncacheRegister(HOST_CNTL);
UncacheRegister(PAT_CNTL);
UncacheRegister(SC_LEFT_RIGHT);
UncacheRegister(SC_TOP_BOTTOM);
UncacheRegister(DP_BKGD_CLR);
UncacheRegister(DP_FRGD_CLR);
UncacheRegister(DP_WRITE_MASK);
UncacheRegister(DP_MIX);
UncacheRegister(CLR_CMP_CNTL);
}
ATIDRIWaitForIdle(pATI);
outr( BUS_CNTL, pATIHW->bus_cntl );
/* DRI uses GUI_TRAJ_CNTL, which is a composite of
* src_cntl, dst_cntl, pat_cntl, and host_cntl
*/
outf( SRC_CNTL, pATIHW->src_cntl );
outf( DST_CNTL, pATIHW->dst_cntl );
outf( PAT_CNTL, pATIHW->pat_cntl );
outf( HOST_CNTL, pATIHW->host_cntl );
outf( DST_OFF_PITCH, pATIHW->dst_off_pitch );
outf( SRC_OFF_PITCH, pATIHW->src_off_pitch );
outf( DP_SRC, pATIHW->dp_src );
outf( DP_MIX, pATIHW->dp_mix );
outf( DP_FRGD_CLR, pATIHW->dp_frgd_clr );
outf( DP_WRITE_MASK, pATIHW->dp_write_mask );
outf( DP_PIX_WIDTH, pATIHW->dp_pix_width );
outf( CLR_CMP_CNTL, pATIHW->clr_cmp_cntl );
outf( ALPHA_TST_CNTL, 0 );
outf( Z_CNTL, 0 );
outf( SCALE_3D_CNTL, 0 );
ATIMach64WaitForFIFO(pATI, 2);
outf( SC_LEFT_RIGHT,
SetWord(pATIHW->sc_right, 1) | SetWord(pATIHW->sc_left, 0) );
outf( SC_TOP_BOTTOM,
SetWord(pATIHW->sc_bottom, 1) | SetWord(pATIHW->sc_top, 0) );
if (pATI->OptionMMIOCache) {
/* Now that the cache slots reflect the register state, re-enable MMIO cache */
CacheRegister(SRC_CNTL);
CacheRegister(HOST_CNTL);
CacheRegister(PAT_CNTL);
CacheRegister(SC_LEFT_RIGHT);
CacheRegister(SC_TOP_BOTTOM);
CacheRegister(DP_BKGD_CLR);
CacheRegister(DP_FRGD_CLR);
CacheRegister(DP_WRITE_MASK);
CacheRegister(DP_MIX);
CacheRegister(CLR_CMP_CNTL);
}
ATIMach64WaitForIdle(pATI);
if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache) {
/* Only check registers we didn't restore */
TestRegisterCaching(PAT_REG0);
TestRegisterCaching(PAT_REG1);
TestRegisterCaching(CLR_CMP_CLR);
TestRegisterCaching(CLR_CMP_MSK);
if (pATI->Block1Base)
{
TestRegisterCaching(OVERLAY_Y_X_START);
TestRegisterCaching(OVERLAY_Y_X_END);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_CLR);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_MSK);
TestRegisterCaching(OVERLAY_KEY_CNTL);
TestRegisterCaching(OVERLAY_SCALE_INC);
TestRegisterCaching(OVERLAY_SCALE_CNTL);
TestRegisterCaching(SCALER_HEIGHT_WIDTH);
TestRegisterCaching(SCALER_TEST);
TestRegisterCaching(VIDEO_FORMAT);
if (pATI->Chip < ATI_CHIP_264VTB)
{
TestRegisterCaching(BUF0_OFFSET);
TestRegisterCaching(BUF0_PITCH);
TestRegisterCaching(BUF1_OFFSET);
TestRegisterCaching(BUF1_PITCH);
}
else
{
TestRegisterCaching(SCALER_BUF0_OFFSET);
TestRegisterCaching(SCALER_BUF1_OFFSET);
TestRegisterCaching(SCALER_BUF_PITCH);
TestRegisterCaching(OVERLAY_EXCLUSIVE_HORZ);
TestRegisterCaching(OVERLAY_EXCLUSIVE_VERT);
if (pATI->Chip >= ATI_CHIP_264GTPRO)
{
TestRegisterCaching(SCALER_COLOUR_CNTL);
TestRegisterCaching(SCALER_H_COEFF0);
TestRegisterCaching(SCALER_H_COEFF1);
TestRegisterCaching(SCALER_H_COEFF2);
TestRegisterCaching(SCALER_H_COEFF3);
TestRegisterCaching(SCALER_H_COEFF4);
TestRegisterCaching(SCALER_BUF0_OFFSET_U);
TestRegisterCaching(SCALER_BUF0_OFFSET_V);
TestRegisterCaching(SCALER_BUF1_OFFSET_U);
TestRegisterCaching(SCALER_BUF1_OFFSET_V);
}
}
}
}
pATI->NeedDRISync = FALSE;
}
else
#endif /* XF86DRI_DEVEL */
{
ATIMach64WaitForIdle(pATI);
if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache)
{
/*
* For debugging purposes, attempt to verify that each cached register
* should actually be cached.
*/
TestRegisterCaching(SRC_CNTL);
TestRegisterCaching(HOST_CNTL);
TestRegisterCaching(PAT_REG0);
TestRegisterCaching(PAT_REG1);
TestRegisterCaching(PAT_CNTL);
if (RegisterIsCached(SC_LEFT_RIGHT) && /* Special case */
(CacheSlot(SC_LEFT_RIGHT) !=
(SetWord(inm(SC_RIGHT), 1) | SetWord(inm(SC_LEFT), 0))))
{
UncacheRegister(SC_LEFT_RIGHT);
xf86DrvMsg(pScreenInfo->scrnIndex, X_WARNING,
"SC_LEFT_RIGHT write cache disabled!\n");
}
if (RegisterIsCached(SC_TOP_BOTTOM) && /* Special case */
(CacheSlot(SC_TOP_BOTTOM) !=
(SetWord(inm(SC_BOTTOM), 1) | SetWord(inm(SC_TOP), 0))))
{
UncacheRegister(SC_TOP_BOTTOM);
xf86DrvMsg(pScreenInfo->scrnIndex, X_WARNING,
"SC_TOP_BOTTOM write cache disabled!\n");
}
TestRegisterCaching(DP_BKGD_CLR);
TestRegisterCaching(DP_FRGD_CLR);
TestRegisterCaching(DP_WRITE_MASK);
TestRegisterCaching(DP_MIX);
TestRegisterCaching(CLR_CMP_CLR);
TestRegisterCaching(CLR_CMP_MSK);
TestRegisterCaching(CLR_CMP_CNTL);
if (pATI->Block1Base)
{
TestRegisterCaching(OVERLAY_Y_X_START);
TestRegisterCaching(OVERLAY_Y_X_END);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_CLR);
TestRegisterCaching(OVERLAY_GRAPHICS_KEY_MSK);
TestRegisterCaching(OVERLAY_KEY_CNTL);
TestRegisterCaching(OVERLAY_SCALE_INC);
TestRegisterCaching(OVERLAY_SCALE_CNTL);
TestRegisterCaching(SCALER_HEIGHT_WIDTH);
TestRegisterCaching(SCALER_TEST);
TestRegisterCaching(VIDEO_FORMAT);
if (pATI->Chip < ATI_CHIP_264VTB)
{
TestRegisterCaching(BUF0_OFFSET);
TestRegisterCaching(BUF0_PITCH);
TestRegisterCaching(BUF1_OFFSET);
TestRegisterCaching(BUF1_PITCH);
}
else
{
TestRegisterCaching(SCALER_BUF0_OFFSET);
TestRegisterCaching(SCALER_BUF1_OFFSET);
TestRegisterCaching(SCALER_BUF_PITCH);
TestRegisterCaching(OVERLAY_EXCLUSIVE_HORZ);
TestRegisterCaching(OVERLAY_EXCLUSIVE_VERT);
if (pATI->Chip >= ATI_CHIP_264GTPRO)
{
TestRegisterCaching(SCALER_COLOUR_CNTL);
TestRegisterCaching(SCALER_H_COEFF0);
TestRegisterCaching(SCALER_H_COEFF1);
TestRegisterCaching(SCALER_H_COEFF2);
TestRegisterCaching(SCALER_H_COEFF3);
TestRegisterCaching(SCALER_H_COEFF4);
TestRegisterCaching(SCALER_BUF0_OFFSET_U);
TestRegisterCaching(SCALER_BUF0_OFFSET_V);
TestRegisterCaching(SCALER_BUF1_OFFSET_U);
TestRegisterCaching(SCALER_BUF1_OFFSET_V);
}
}
}
}
}
/*
* For VTB's and later, the first CPU read of the framebuffer will return
* zeroes, so do it here. This appears to be due to some kind of engine
* caching of framebuffer data I haven't found any way of disabling, or
* otherwise circumventing. Thanks to Mark Vojkovich for the suggestion.
*/
if (pATI->pXAAInfo)
pATI->pXAAInfo->NeedToSync = FALSE;
pATI = *(volatile ATIPtr *)pATI->pMemory;
}
int main()
{
// construction
// we can build a document piece by piece...
InfoResBase objAPA;
objAPA.addString("Name", "Schlafly American Pale Ale");
objAPA.addString("Name", "Schlafly American Pale Ale");
objAPA.addString("Origin", "St. Louis, MO, USA");
objAPA.addNumber("ABV", 3.8);
objAPA.addBoolean("BottleConditioned", true);
InfoResBase objBPB;
objBPB.addString("Name", "John Smith's Extra Smooth");
objBPB.addString("Origin", "Tadcaster, Yorkshire, UK");
objBPB.addNumber("ABV", 3.8);
objBPB.addBoolean("BottleConditioned", false);
InfoResArray arrayBeer;
arrayBeer.insert(objAPA);
arrayBeer.insert(objBPB);
InfoResBase objDocument;
objDocument.addArray("Delicious Beers", arrayBeer);
objDocument.addObject("aaa", objAPA);
std::cout << objDocument.toJson() << std::endl;
std::cout << "----------- Address Group -----------" << std::endl;
// address group
EndpointAddrGroup group;
std::vector<const char*> ipv4;
ipv4.push_back("192.0.2.0/24");
ipv4.push_back("198.51.100.0/25");
std::vector<const char*> ipv6;
ipv6.push_back("2001:db8:0:1::/64");
ipv6.push_back("2001:db8:0:2::/64");
group.setIPv4(ipv4);
group.setIPv6(ipv6);
std::cout << group.toJson() << std::endl;
std::cout << "----------- Resource Directory -----------" << std::endl;
std::vector<ResourceEntry> res(5);
res[0].addUri("http://alto.example.com/networkmap");
std::vector<const char*> mtypes;
mtypes.push_back("application/alto-networkmap+json");
res[0].addMediaTypes(mtypes);
std::vector<const char*> accepts;
res[1].addUri("http://alto.example.com/costmap/num/routingcost");
mtypes.clear();
mtypes.push_back("application/alto-costmap+json");
res[1].addMediaTypes(mtypes);
accepts.clear();
res[2].addUri("http://alto.example.com/costmap/num/hopcount");
mtypes.clear();
mtypes.push_back("application/alto-costmap+json");
res[2].addMediaTypes(mtypes);
accepts.clear();
res[3].addUri("http://custom.alto.example.com/maps");
mtypes.clear();
mtypes.push_back("application/alto-networkmapfilter+json");
mtypes.push_back("application/alto-costmapfilter+json");
res[3].addMediaTypes(mtypes);
accepts.clear();
accepts.push_back("application/alto-networkmapfilter+json");
accepts.push_back("application/alto-costmapfilter+json");
res[3].addAccepts(accepts);
res[4].addUri("http://alto.example.com/endpointprop/lookup");
mtypes.clear();
mtypes.push_back("application/alto-endpointprop+json");
res[4].addMediaTypes(mtypes);
accepts.clear();
accepts.push_back("application/alto-endpointpropparams+json");
res[4].addAccepts(accepts);
Capability cap;
std::vector<const char*> vec;
vec.push_back("numerical");
cap.addCapability("cost-modes", vec);
vec.clear();
vec.push_back("routingcost");
cap.addCapability("cost-types", vec);
res[1].addCapability(cap);
vec.clear();
cap.clear();
vec.push_back("numerical");
cap.addCapability("cost-modes", vec);
vec.clear();
vec.push_back("hopcount");
cap.addCapability("cost-types", vec);
res[2].addCapability(cap);
vec.clear();
cap.clear();
vec.push_back("pid");
cap.addCapability("prop-types", vec);
res[4].addCapability(cap);
InfoResourceDirectory ifd;
ifd.addResources(res);
std::cout << ifd.toJson() << std::endl;
std::cout << "----------- Network Map -------------" << std::endl;
NetworkMap nm;
nm.addPid("PID1", group);
InfoResourceNetworkMap inm("1266506139");
inm.addMap(nm);
InfoResourceEntity ire;
InfoResourceMetaData empty;
ire.setMeta(empty);
ire.setData(inm);
std::cout << ire.toJson() << std::endl;
std::cout << "----------- Cost Map -------------" << std::endl;
InfoResourceCostMap ircm;
ircm.addCostMode("numerical");
ircm.addCostType("routingcost");
ircm.addVertionTag("1266506139");
CostMapData cmd;
DstCosts dcost;
dcost.addDst("PID1", 1);
dcost.addDst("PID2", 5);
dcost.addDst("PID3", 10);
cmd.addDstCost("PID1", dcost);
dcost.clear();
dcost.addDst("PID1", 5);
dcost.addDst("PID2", 1);
dcost.addDst("PID3", 15);
cmd.addDstCost("PID2", dcost);
dcost.clear();
dcost.addDst("PID1", 20);
dcost.addDst("PID2", 15);
dcost.addDst("PID3", 1);
cmd.addDstCost("PID3", dcost);
ircm.addCostMapData(cmd);
ire.setData(ircm);
std::cout << ire.toJson() << std::endl;
}
