int main(int argc, const char **argv)
{
int test_result = 0;
int srcAlloc;
unsigned int *srcBuffer = 0;
fprintf(stderr, "Main::%s %s\n", __DATE__, __TIME__);
DmaManager *dma = platformInit();
ReadTestRequestProxy *device = new ReadTestRequestProxy(IfcNames_ReadTestRequestS2H,TILE_NUMBER);
ReadTestIndication memReadIndication(IfcNames_ReadTestIndicationH2S,TILE_NUMBER);
fprintf(stderr, "Main::allocating memory...\n");
srcAlloc = portalAlloc(alloc_sz, 0);
srcBuffer = (unsigned int *)portalMmap(srcAlloc, alloc_sz);
for (int i = 0; i < numWords; i++)
srcBuffer[i] = i;
portalCacheFlush(srcAlloc, srcBuffer, alloc_sz, 1);
fprintf(stderr, "Main::flush and invalidate complete\n");
/* Test 1: check that match is ok */
unsigned int ref_srcAlloc = dma->reference(srcAlloc);
fprintf(stderr, "ref_srcAlloc=%d\n", ref_srcAlloc);
fprintf(stderr, "Main::orig_test read numWords=%d burstLen=%d iterCnt=%d\n", numWords, burstLen, iterCnt);
portalTimerStart(0);
device->startRead(ref_srcAlloc, numWords * 4, burstLen * 4, iterCnt);
sem_wait(&test_sem);
if (mismatchCount) {
fprintf(stderr, "Main::first test failed to match %d.\n", mismatchCount);
test_result++; // failed
}
platformStatistics();
/* Test 2: check that mismatch is detected */
srcBuffer[0] = -1;
srcBuffer[numWords/2] = -1;
srcBuffer[numWords-1] = -1;
portalCacheFlush(srcAlloc, srcBuffer, alloc_sz, 1);
fprintf(stderr, "Starting second read, mismatches expected\n");
mismatchCount = 0;
device->startRead(ref_srcAlloc, numWords * 4, burstLen * 4, iterCnt);
sem_wait(&test_sem);
if (mismatchCount != 3/*number of errors introduced above*/ * iterCnt) {
fprintf(stderr, "Main::second test failed to match mismatchCount=%d (expected %d) iterCnt=%d numWords=%d.\n",
mismatchCount, 3*iterCnt,
iterCnt, numWords);
test_result++; // failed
}
#if 0
MonkitFile pmf("perf.monkit");
pmf.setHwCycles(cycles)
.setReadBwUtil(read_util)
.writeFile();
#endif
return test_result;
}
double likelihood::eval(double * const params) const
{
double lf = 1.;
for (unsigned int ir = 0; ir < nr_; ir++) {
double nexp = this->nexp(ir, params);
if (nexp > 100. * nobs_[ir]) nexp = 100. * nobs_[ir];
boost::math::poisson pmf(nexp);
lf *= pdf(pmf, nobs_[ir]);
}
for (unsigned int is = 0; is < ns_; is++) {
double loc = params[np_+is];
//if (isnan(loc)) loc = 0.;
if (loc > 20.) loc = 20.;
if (loc < -20.) loc = -20.;
boost::math::normal pdf_syst(loc);
lf *= pdf(pdf_syst, 0.);
}
//for (unsigned int i = 0; i < 100000; i++)
// double x = std::sqrt(i + 1.) / (i + 1.);
return -2. * log(lf);
}
// CHECK: {{define.*_ZN5test81fEv}}
pmf f() {
// CHECK: {{ret.*zeroinitializer}}
return pmf();
}
int main(int argc,char** argv){
std::map<std::string,std::string> input;
input["-ft_sensor_topic"] = "";
input["-virtual_sensor_topic"] = "";
input["-action_topic"] = "";
input["-urdf"] = "";
input["-rate"] = "100";
input["-fixed_frame"] = "/world";
input["-peg_link_name"] = "";
input["-path_sensor_model"] = "";
input["-socket_type"] = "";
if(!opti_rviz::Input::process_input(argc,argv,input)){
ROS_ERROR("failed to load input");
return 0;
}
opti_rviz::Input::print_input_options(input);
std::string ft_sensor_topic = input["-ft_sensor_topic"];
std::string virtual_sensor_topic = input["-virtual_sensor_topic"];
std::string action_topic = input["-action_topic"];
std::string fixed_frame = input["-fixed_frame"];
std::string peg_link_name = input["-peg_link_name"];
std::string srate = input["-rate"];
std::string path_sensor_model = input["-path_sensor_model"];
std::string ssocket_type = input["-socket_type"];
SOCKET_TYPE socket_type;
if(ssocket_type == "one"){
socket_type = SOCKET_TYPE::ONE;
}else if(ssocket_type == "two"){
socket_type = SOCKET_TYPE::TWO;
}else if(ssocket_type == "three"){
socket_type = SOCKET_TYPE::THREE;
}else{
ROS_ERROR_STREAM("No such socket type defined: " + ssocket_type);
return 0;
}
ros::init(argc, argv, "peg_filter");
ros::NodeHandle nh;
double Hz = boost::lexical_cast<float>(srate);
ros::Rate rate(Hz);
ROS_INFO_STREAM("loaded variables! [peg_filter_node]");
/// ---------------------- Variables -----------------------------
arma::colvec3 peg_origin;
arma::mat33 peg_orient;
/// ------------------ Virtual Sensor for Particles -------------------------
Peg_world_wrapper peg_world_wrapper(nh,socket_type,true,"peg_world_wrapper",path_sensor_model,fixed_frame,peg_link_name); // don't publish needs the model for the likelihood
psm::Contact_distance_model contact_distance_model(*(peg_world_wrapper.peg_sensor_model.get()));
psm::Sensor_manager sensor_manager(nh);
sensor_manager.add("contact",&contact_distance_model);
if(!sensor_manager.select_model("contact")){
ROS_ERROR("FAILED to select_model");
exit(0);
}
/// ------------------ Sensor Variables -------------------------
psm::Peg_sensor_listener ft_sensor_listener(nh,ft_sensor_topic);
psm::Peg_sensor_listener virtual_sensor_listener(nh,virtual_sensor_topic);
arma::colvec& Y_ft = ft_sensor_listener.Y;
arma::colvec& Y_virtual = virtual_sensor_listener.Y;
arma::colvec Y_mixed;
int Y_type = 3;
Y_mixed.resize(10);
opti_rviz::Publisher pub_mix(nh,"mixed_classifier");
/// ------------------ Point Mass Filter -------------------------
///
///
///
///
bool bExperiment = true;
// Debug
int init_pmf_type = 10;
int init_pmf_pos = 1;
// experiment
int init_pmf_exp = 1;
int init_exp_pos = 1;
///
///
/// Dimension of Measurement
int dim_Y = 12;
//likeli::Binary_likelihood binary_likelihood;
likeli::Mixed_likelihood mixed_likelihood(nh,peg_world_wrapper.get_wrapped_objects(),peg_origin);
pf::Measurement_h peg_measurement = std::bind(&psm::Sensor_manager::compute_hY,&sensor_manager,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3);
pf::likelihood_model peg_likelihood;
// the type of likelihood function will depend on the sensor (FT/virtual)
if(Y_type == 0)
{
// peg_likelihood = std::bind(&likeli::Binary_likelihood::likelihood,&binary_likelihood,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3);
}else if(Y_type == 2)
{
peg_likelihood = std::bind(&likeli::Mixed_likelihood::likelihood,&mixed_likelihood,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3,std::placeholders::_4);
}else if (Y_type == 3)
{
if(socket_type == SOCKET_TYPE::ONE){
ROS_WARN("SETTING LIKELIHOOD TO SOCKET ONE");
peg_likelihood = std::bind(&likeli::Mixed_likelihood::likelihood,&mixed_likelihood,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3,std::placeholders::_4);
}else if(socket_type == SOCKET_TYPE::TWO){
ROS_WARN("SETTING LIKELIHOOD TO SOCKET TWO");
peg_likelihood = std::bind(&likeli::Mixed_likelihood::likelihood_stwo,&mixed_likelihood,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3,std::placeholders::_4);
}else if(socket_type == SOCKET_TYPE::THREE){
ROS_WARN("SETTING LIKELIHOOD TO SOCKET THREE");
peg_likelihood = std::bind(&likeli::Mixed_likelihood::likelihood_sthree,&mixed_likelihood,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3,std::placeholders::_4);
}else{
ROS_ERROR("PEG FILTER NO SUCH SOCKET TYPE");
}
}else{
ROS_ERROR_STREAM("No such [" << Y_type << "] defined!");
exit(0);
}
pf::Point_mass_filter::delta delta_;
pf::Point_mass_filter::length length_;
if(bExperiment){
init_delta_length_experiment(init_pmf_exp,delta_,length_);
}else{
init_delta_length(init_pmf_type,delta_,length_);
}
pf::Point_mass_filter pmf(peg_likelihood,peg_measurement,delta_,length_,dim_Y);
arma::colvec3 peg_position;
{
tf::StampedTransform transform;
opti_rviz::Listener::get_tf_once(fixed_frame,peg_link_name,transform);
opti_rviz::type_conv::tf2vec(transform.getOrigin(),peg_position);
}
arma::colvec3 table_position;
{
tf::StampedTransform transform;
opti_rviz::Listener::get_tf_once(fixed_frame,"link_wall",transform);
opti_rviz::type_conv::tf2vec(transform.getOrigin(),table_position);
}
arma::colvec3 socket_position;
{
tf::StampedTransform transform;
opti_rviz::Listener::get_tf_once(fixed_frame,"link_socket",transform);
opti_rviz::type_conv::tf2vec(transform.getOrigin(),socket_position);
}
if(bExperiment){
initialise_prior_experiment(init_pmf_exp,pmf,peg_position(0),peg_position(1),peg_position(2));
}else{
initialise_prior_pdf(init_pmf_pos,init_pmf_type,pmf,peg_position(0),peg_position(1),peg_position(2));
}
std::cout<< "pmf prior initialised [peg_filter_node]" << std::endl;
//binary_likelihood.set_resolution(&pmf.get_delta());
mixed_likelihood.set_resolution(&pmf.get_delta());
std::cout<< "binary_likelihood set [peg_filter_node]" << std::endl;
plugfilter::Plug_pf_manager plug_pf_manager;
plug_pf_manager.add(&pmf,"pmf");
if(!plug_pf_manager.select_method("pmf")){
ROS_ERROR("did not manage to select pmf [peg_filter_node]");
}
plug_pf_manager.init_visualise(nh);
plug_pf_manager.set_pf_color_type(pf::C_WEIGHTS);
plug_pf_manager.set_visualise_mode(opti_rviz::Vis_point_cloud::DEFAULT);
/// ------------------- Filter Manager Service ---------------------
plugfilter::Plug_service plug_service(nh,plug_pf_manager);
plugfilter::Plug_service::Initialise initialise_f = std::bind(initialise_prior_pdf,init_pmf_pos,init_pmf_type,std::ref(pmf),std::placeholders::_1,std::placeholders::_2,std::placeholders::_3);
plugfilter::Plug_service::Initialise initialise_ex = std::bind(initialise_prior_experiment,init_pmf_exp,std::ref(pmf),std::placeholders::_1,std::placeholders::_2,std::placeholders::_3);
if(bExperiment){
plug_service.set_initilisation_function(&initialise_ex);
}else{
plug_service.set_initilisation_function(&initialise_f);
}
std::cout<< "Plug_service set [peg_filter_node]" << std::endl;
/// Listeners Velocity
opti_rviz::Listener peg_tip_position_listener(fixed_frame,action_topic);
tf::Vector3 peg_origin_tf;
tf::Vector3 peg_origin_tf_tmp;
tf::Matrix3x3 peg_orient_tf;
peg_tip_position_listener.update(peg_origin_tf,peg_orient_tf);
peg_origin_tf_tmp = peg_origin_tf;
/// ------------------ Belief Compression ------------------
Belief_compression belief_compression;
// advertised on topic [mode_feature]
ModeBeliefCompress mode_belief_compression(nh,"mode_entropy");
belief_compression.add_bel_compress_method(&mode_belief_compression);
if(belief_compression.set_method("mode_entropy"))
{
ROS_INFO("belief compression set [peg_filter_node]");
}else{
ROS_ERROR("belief compression not set [peg_filter_node]");
exit(0);
}
/// ------------ Get Fist time Position and Orientation ------------
tf::Matrix3x3 Rot_peg;
Rot_peg.setRPY(0,0,M_PI);
arma::colvec3 u;
peg_orient.zeros();
peg_origin.zeros();
bool bcorrect_orient = false;
peg_origin_tf_tmp = peg_origin_tf;
while(nh.ok() && (bcorrect_orient == false))
{
peg_tip_position_listener.update(peg_origin_tf,peg_orient_tf);
opti_rviz::type_conv::tf2mat(peg_orient_tf,peg_orient);
opti_rviz::type_conv::tf2vec(peg_origin_tf,peg_origin);
bcorrect_orient = arma::any(arma::vectorise(peg_orient));
ros::spinOnce();
rate.sleep();
}
peg_origin_tf_tmp = peg_origin_tf;
get_veclocity(u,peg_origin_tf,peg_origin_tf_tmp);
u.print("u");
peg_orient.print("peg_orient");
/// ------------ Remove Bias from FT sensor --------------
ros::ServiceClient client = nh.serviceClient<netft_rdt_driver::String_cmd>("/ft_sensor/bias_cmd");
ros::Subscriber sub_ft_bias_status = nh.subscribe("/ft_sensor/bias_status", 10, bias_status_callback);
netft_rdt_driver::String_cmd srv;
srv.request.cmd = "bias";
srv.response.res = "";
if (client.call(srv))
{
ROS_INFO_STREAM("net_ft res: " << srv.response.res);
}
else
{
ROS_ERROR("Failed to call netft bias service [peg_filter_node]");
}
while(nh.ok() && !bBiasUpdated)
{
ros::spinOnce();
rate.sleep();
}
ROS_INFO("bias reset");
/// ------------ Wait a litte bit ------------
{
while(nh.ok() && Y_ft(0) != 0){
std::cout << "waiting all zero Y: " << Y_ft(0) << " " << Y_ft(1) << " " << Y_ft(2) << std::endl;
ros::spinOnce();
rate.sleep();
}
}
tf::Quaternion qtmp;
qtmp.setX(0);
qtmp.setY(-0.5);
qtmp.setZ(0);
qtmp.setW(0.5);
arma::colvec3 wall_position;
{
tf::StampedTransform transform;
opti_rviz::Listener::get_tf_once("world","link_wall",transform);
opti_rviz::type_conv::tf2vec(transform.getOrigin(),wall_position);
}
opti_rviz::Vis_point_cloud vis_pc_rec(nh,"pfilter_record");
vis_pc_rec.set_channel(opti_rviz::Vis_point_cloud::CHANNEL_TYPE::Intensity);
vis_pc_rec.initialise("world",pmf.points);
arma::colvec3 plan_norm;
plan_norm(0) = 1; plan_norm(1) = 0; plan_norm(2) = 0;
arma::colvec3 target,mode_SF, mode, tt, bb;
target = table_position;
target(0) = target(0) + 0.026;
ros::Time start_time = ros::Time::now();
while(nh.ok()){
// const auto start_time = std::chrono::steady_clock::now();
peg_world_wrapper.update();
peg_tip_position_listener.update(peg_origin_tf,peg_orient_tf);
get_veclocity(u,peg_origin_tf,peg_origin_tf_tmp);
peg_orient_tf.setRotation(qtmp);
opti_rviz::type_conv::tf2mat(peg_orient_tf,peg_orient);
opti_rviz::type_conv::tf2vec(peg_origin_tf,peg_origin);
bcorrect_orient = arma::any(arma::vectorise(peg_orient));
mode = mode_belief_compression.get_mode();
bb = pmf.bbox.bb - socket_position;
tt = pmf.bbox.tt - socket_position;
mode_SF = mode - socket_position;
if(!(Y_ft.is_empty()) && bcorrect_orient){
opti_rviz::debug::tf_debuf(bb,"BB");
opti_rviz::debug::tf_debuf(tt,"TT");
if(Y_ft(0) == 1 && is_above_table(bb) && is_above_table(tt) && !is_in_socket_area(bb,tt)){
// ROS_INFO_STREAM_THROTTLE(0.2,"----------------> Is above table");
if(mode_SF.is_finite()){
// u(0) = 0.01 * (0.02 - mode_SF(0));
}else{
ROS_INFO_STREAM_THROTTLE(1.0, "MODE_SF IS NOT FINITE");
}
}else if(Y_ft(0) == 1 && !Y_virtual(psm::Contact_distance_model::C_SOCKET))
{
// u(0) = 0;
}
switch (Y_type) {
case 0:
{
plug_pf_manager.update(Y_ft,u,peg_orient,Hz);
break;
}
case 1:
{
plug_pf_manager.update(Y_virtual,u,peg_orient,Hz);
break;
}
case 2:
{
Y_mixed(0) = Y_ft(0); // contact / no contact
Y_mixed(1) = Y_ft(1); // Fx
Y_mixed(2) = Y_ft(2); // Fy
Y_mixed(3) = Y_ft(3); // Fz
Y_mixed(4) = Y_ft(4); // prob_left_edge
Y_mixed(5) = Y_ft(5); // prob_right_edge
Y_mixed(6) = Y_ft(6); // prob_up_edge
Y_mixed(7) = Y_ft(7); // prob_down_edge
pub_mix.publish(Y_mixed);
plug_pf_manager.update(Y_mixed,u,peg_orient,Hz);
break;
}
case 3:
{
/*
C_SURF =0
C_EDGE_DIST =1
C_EDGE_LEFT =2
C_EDGE_RIGHT =3
C_EDGE_TOP =4
C_EDGE_BOT =5
C_RING =6
C_S_HOLE =7
C_SOCKET =8
C_EDGE_V1 =9
C_EDGE_V2 =10
C_EDGE_V3 =11
*/
Y_mixed(0) = Y_ft(0); // contact / no contact
Y_mixed(1) = Y_virtual(psm::Contact_distance_model::C_EDGE_DIST); // Fx
Y_mixed(2) = Y_virtual(psm::Contact_distance_model::C_EDGE_V2); // Fy
Y_mixed(3) = Y_virtual(psm::Contact_distance_model::C_EDGE_V3); // Fz
Y_mixed(4) = Y_virtual(psm::Contact_distance_model::C_EDGE_LEFT); // prob_left_edge
Y_mixed(5) = Y_virtual(psm::Contact_distance_model::C_EDGE_RIGHT); // prob_right_edge
Y_mixed(6) = Y_virtual(psm::Contact_distance_model::C_EDGE_TOP); // prob_up_edge
Y_mixed(7) = Y_virtual(psm::Contact_distance_model::C_EDGE_BOT); // prob_down_edge
Y_mixed(8) = Y_virtual(psm::Contact_distance_model::C_SOCKET); // Y_socket
Y_mixed(9) = Y_virtual(psm::Contact_distance_model::C_RING); // Closest distance to ring edge
pub_mix.publish(Y_mixed);
plug_pf_manager.update(Y_mixed,u,peg_orient,Hz);
break;
}
default:
break;
}
/// belief feature (belief compression) computation
belief_compression.update(u,pmf.points,pmf.P);
}
/// particle filter visualisation
plug_pf_manager.visualise();
/// particle filter vis for recording
if( (ros::Time::now() - start_time).toSec() > 0.02 ){
vis_pc_rec.update(pmf.points,pmf.P.memptr());
vis_pc_rec.publish();
start_time = ros::Time::now();
}
peg_origin_tf_tmp = peg_origin_tf;
ros::spinOnce();
rate.sleep();
}
return 0;
}
int main(int argc, const char **argv)
{
if(sem_init(&done_sem, 1, 0)) {
fprintf(stderr, "failed to init done_sem\n");
exit(1);
}
if(sem_init(&memcmp_sem, 1, 0)) {
fprintf(stderr, "failed to init memcmp_sem\n");
exit(1);
}
fprintf(stderr, "%s %s\n", __DATE__, __TIME__);
MemcpyRequestProxy *device = new MemcpyRequestProxy(IfcNames_MemcpyRequestS2H);
deviceIndication = new MemcpyIndication(IfcNames_MemcpyIndicationH2S);
DmaManager *dma = platformInit();
fprintf(stderr, "Main::allocating memory...\n");
srcAlloc = portalAlloc(alloc_sz, 0);
dstAlloc = portalAlloc(alloc_sz, 0);
// for(int i = 0; i < srcAlloc->header.numEntries; i++)
// fprintf(stderr, "%lx %lx\n", srcAlloc->entries[i].dma_address, srcAlloc->entries[i].length);
// for(int i = 0; i < dstAlloc->header.numEntries; i++)
// fprintf(stderr, "%lx %lx\n", dstAlloc->entries[i].dma_address, dstAlloc->entries[i].length);
srcBuffer = (unsigned int *)portalMmap(srcAlloc, alloc_sz);
dstBuffer = (unsigned int *)portalMmap(dstAlloc, alloc_sz);
for (int i = 0; i < numWords; i++) {
srcBuffer[i] = i;
dstBuffer[i] = 0x5a5abeef;
}
portalCacheFlush(srcAlloc, srcBuffer, alloc_sz, 1);
portalCacheFlush(dstAlloc, dstBuffer, alloc_sz, 1);
fprintf(stderr, "Main::flush and invalidate complete\n");
unsigned int ref_srcAlloc = dma->reference(srcAlloc);
unsigned int ref_dstAlloc = dma->reference(dstAlloc);
fprintf(stderr, "ref_srcAlloc=%d\n", ref_srcAlloc);
fprintf(stderr, "ref_dstAlloc=%d\n", ref_dstAlloc);
// unsigned int refs[2] = {ref_srcAlloc, ref_dstAlloc};
// for(int j = 0; j < 2; j++){
// unsigned int ref = refs[j];
// for(int i = 0; i < numWords; i = i+(numWords/4)){
// dmap->addrRequest(ref, i*sizeof(unsigned int));
// sleep(1);
// }
// dmap->addrRequest(ref, (1<<16)*sizeof(unsigned int));
// sleep(1);
// }
fprintf(stderr, "Main::starting memcpy numWords:%d\n", numWords);
int burstLen = 32;
#ifndef SIMULATION
int iterCnt = 128;
#else
int iterCnt = 2;
#endif
portalTimerStart(0);
device->startCopy(ref_dstAlloc, ref_srcAlloc, numWords, burstLen, iterCnt);
sem_wait(&done_sem);
platformStatistics();
//float read_util = (float)read_beats/(float)cycles;
//float write_util = (float)write_beats/(float)cycles;
//fprintf(stderr, " iters: %d\n", iterCnt);
//fprintf(stderr, "wr_beats: %"PRIx64" %08lx\n", write_beats, (long)write_beats);
//fprintf(stderr, "rd_beats: %"PRIx64" %08lx\n", read_beats, (long)read_beats);
//fprintf(stderr, "numWords: %x\n", numWords);
//fprintf(stderr, " wr_est: %"PRIx64"\n", (write_beats*2)/iterCnt);
//fprintf(stderr, " rd_est: %"PRIx64"\n", (read_beats*2)/iterCnt);
//fprintf(stderr, "memory read utilization (beats/cycle): %f\n", read_util);
//fprintf(stderr, "memory write utilization (beats/cycle): %f\n", write_util);
#if 0
MonkitFile pmf("perf.monkit");
pmf.setHwCycles(cycles)
.setReadBwUtil(read_util)
.setWriteBwUtil(write_util)
.writeFile();
fprintf(stderr, "After updating perf.monkit\n");
#endif
sem_wait(&memcmp_sem);
fprintf(stderr, "after memcmp_sem memcmp_fail=%d\n", memcmp_fail);
return memcmp_fail;
}
void f()
{
pointmemfun pmf(0); // { dg-warning "zero as null pointer" }
pointdmem pdm(0); // { dg-warning "zero as null pointer" }
pointfun pf(0); // { dg-warning "zero as null pointer" }
int* p(0); // { dg-warning "zero as null pointer" }
pointmemfun pmfn(nullptr);
pointdmem pdmn(nullptr);
pointfun pfn(nullptr);
int* pn(nullptr);
pmf = 0; // { dg-warning "zero as null pointer" }
pdm = 0; // { dg-warning "zero as null pointer" }
pf = 0; // { dg-warning "zero as null pointer" }
p = 0; // { dg-warning "zero as null pointer" }
pmf = nullptr;
pdm = nullptr;
pf = nullptr;
p = nullptr;
if (pmf)
;
if (pdm)
;
if (pf)
;
if (p)
;
if (!pmf)
;
if (!pdm)
;
if (!pf)
;
if (!p)
;
if (pmf == 0) // { dg-warning "zero as null pointer" }
;
if (pdm == 0) // { dg-warning "zero as null pointer" }
;
if (pf == 0) // { dg-warning "zero as null pointer" }
;
if (p == 0) // { dg-warning "zero as null pointer" }
;
if (0 == pmf) // { dg-warning "zero as null pointer" }
;
if (0 == pdm) // { dg-warning "zero as null pointer" }
;
if (0 == pf) // { dg-warning "zero as null pointer" }
;
if (0 == p) // { dg-warning "zero as null pointer" }
;
if (pmf != 0) // { dg-warning "zero as null pointer" }
;
if (pdm != 0) // { dg-warning "zero as null pointer" }
;
if (pf != 0) // { dg-warning "zero as null pointer" }
;
if (p != 0) // { dg-warning "zero as null pointer" }
;
if (0 != pmf) // { dg-warning "zero as null pointer" }
;
if (0 != pdm) // { dg-warning "zero as null pointer" }
;
if (0 != pf) // { dg-warning "zero as null pointer" }
;
if (0 != p) // { dg-warning "zero as null pointer" }
;
if (pmf == nullptr)
;
if (pdm == nullptr)
;
if (pf == nullptr)
;
if (p == nullptr)
;
if (nullptr == pmf)
;
if (nullptr == pdm)
;
if (nullptr == pf)
;
if (nullptr == p)
;
if (pmf != nullptr)
;
if (pdm != nullptr)
;
if (pf != nullptr)
;
if (p != nullptr)
;
if (nullptr != pmf)
;
if (nullptr != pdm)
;
if (nullptr != pf)
;
if (nullptr != p)
;
}
