自学教程：C++ y1函数代码示例

doubleyn (int n, double x) {  int i, sign;  double a, b, tmp;    if (x <= 0)    return (dzero/dzero);	/* IEEE machines: invalid operation */  sign = 1;  if (n < 0)    {      n = -n;      if (n%2 == 1) 	sign = -1;    }  if (n == 0)     return y0(x);  if (n == 1)     return sign*y1(x);  a = y0(x);  b = y1(x);  for (i = 1; i<n; i++)    {      tmp = b;      b = (2.0*i / x) * b - a;      a = tmp;    }  return sign*b;}

/* MapLine::needsTexture * Returns a flag set of any parts of the line that require a texture *******************************************************************/int MapLine::needsTexture(){	// Check line is valid	if (!frontSector())		return 0;	// If line is 1-sided, it only needs front middle	if (!backSector())		return TEX_FRONT_MIDDLE;	// Get sector planes	plane_t floor_front = frontSector()->getFloorPlane();	plane_t ceiling_front = frontSector()->getCeilingPlane();	plane_t floor_back = backSector()->getFloorPlane();	plane_t ceiling_back = backSector()->getCeilingPlane();	double front_height, back_height;	int tex = 0;	// Check the floor	front_height = floor_front.height_at(x1(), y1());	back_height = floor_back.height_at(x1(), y1());	if (front_height - back_height > EPSILON)		tex |= TEX_BACK_LOWER;	if (back_height - front_height > EPSILON)		tex |= TEX_FRONT_LOWER;	front_height = floor_front.height_at(x2(), y2());	back_height = floor_back.height_at(x2(), y2());	if (front_height - back_height > EPSILON)		tex |= TEX_BACK_LOWER;	if (back_height - front_height > EPSILON)		tex |= TEX_FRONT_LOWER;	// Check the ceiling	front_height = ceiling_front.height_at(x1(), y1());	back_height = ceiling_back.height_at(x1(), y1());	if (back_height - front_height > EPSILON)		tex |= TEX_BACK_UPPER;	if (front_height - back_height > EPSILON)		tex |= TEX_FRONT_UPPER;	front_height = ceiling_front.height_at(x2(), y2());	back_height = ceiling_back.height_at(x2(), y2());	if (back_height - front_height > EPSILON)		tex |= TEX_BACK_UPPER;	if (front_height - back_height > EPSILON)		tex |= TEX_FRONT_UPPER;	return tex;}

void Quad::set_range(double nx1, double nx2, double ny1, double ny2){	*x1() = nx1;	*x2() = nx2;	*y1() = ny1;	*y2() = ny2;	*x_mid() = ( *x1() + *x2() )*0.5f;	*y_mid() = ( *y1() + *y2() )*0.5f;}

doubleyn(int n, double x){	int i, sign;	double a, b, temp;    /* Y(n,NaN), Y(n, x < 0) is NaN */	if (x <= 0 || isnan(x))		if (_IEEE && x < 0) return zero/zero;		else if (x < 0)     return (infnan(EDOM));		else if (_IEEE)     return -one/zero;		else		    return(infnan(-ERANGE));	else if (!finite(x)) return(0);	sign = 1;	if (n<0){		n = -n;		sign = 1 - ((n&1)<<2);	}	if (n == 0) return(y0(x));	if (n == 1) return(sign*y1(x));	if(_IEEE && x >= 8.148143905337944345e+090) { /* x > 2**302 */    /* (x >> n**2)     *	    Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)     *	    Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)     *	    Let s=sin(x), c=cos(x),     *		xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then     *     *		   n	sin(xn)*sqt2	cos(xn)*sqt2     *		----------------------------------     *		   0	 s-c		 c+s     *		   1	-s-c 		-c+s     *		   2	-s+c		-c-s     *		   3	 s+c		 c-s     */		switch (n&3) {		    case 0: temp =  sin(x)-cos(x); break;		    case 1: temp = -sin(x)-cos(x); break;		    case 2: temp = -sin(x)+cos(x); break;		    case 3: temp =  sin(x)+cos(x); break;		}		b = invsqrtpi*temp/sqrt(x);	} else {	    a = y0(x);	    b = y1(x);	/* quit if b is -inf */	    for (i = 1; i < n && !finite(b); i++){		temp = b;		b = ((double)(i+i)/x)*b - a;		a = temp;	    }	}	if (!_IEEE && !finite(b))		return (infnan(-sign * ERANGE));	return ((sign > 0) ? b : -b);}

bool SimpleRegion::intersects(SimpleRegion obstacle) {  return (    (      (x1() <= obstacle.x1() && obstacle.x1() <= x2())      ||      (x1() <= obstacle.x2() && obstacle.x2() <= x2())    )    &&    (      (y1() <= obstacle.y1() && obstacle.y1() <= y2())      ||      (y1() <= obstacle.y2() && obstacle.y2() <= y2())    )  );}

void Terrain::split(){	if(is_split())		return;	quads[0][0] = new Terrain(V);	quads[0][1] = new Terrain(V);	quads[1][0] = new Terrain(V);	quads[1][1] = new Terrain(V);	quads[0][0]->set_range(*x1(), *x_mid(), *y1(), *y_mid());	quads[0][1]->set_range(*x_mid(), *x2(), *y1(), *y_mid());	quads[1][0]->set_range(*x1(), *x_mid(), *y_mid(), *y2());	quads[1][1]->set_range(*x_mid(), *x2(), *y_mid(), *y2());}

void Quad::split(){	if(is_split())		return;	quads[0][0] = new Quad(V);	quads[0][1] = new Quad(V);	quads[1][0] = new Quad(V);	quads[1][1] = new Quad(V);		quads[0][0]->set_range( *x1(), *x_mid(), *y1(), *y_mid() );	quads[0][1]->set_range( *x_mid(), *x2(), *y1(), *y_mid() );	quads[1][0]->set_range( *x1(), *x_mid(), *y_mid(), *y2() );	quads[1][1]->set_range( *x_mid(), *x2(), *y_mid(), *y2() );}

std::vector< std::vector<Real> > ElectroIonicModel::getJac (const std::vector<Real>& v, Real h){    std::vector< std::vector<Real> > J ( M_numberOfEquations, std::vector<Real> (M_numberOfEquations, 0.0) );    std::vector<Real> f1 (M_numberOfEquations, 0.0);    std::vector<Real> f2 (M_numberOfEquations, 0.0);    std::vector<Real> y1 (M_numberOfEquations, 0.0);    std::vector<Real> y2 (M_numberOfEquations, 0.0);    for (int i = 0; i < M_numberOfEquations; i++)    {        for (int j = 0; j < M_numberOfEquations; j++)        {            y1[j] = v[j] + ( (double) (i == j) ) * h;            y2[j] = v[j] - ( (double) (i == j) ) * h;        }        this->computeRhs (y1, f1);        f1[0] += M_appliedCurrent;        this->computeRhs (y2, f2);        f2[0] += M_appliedCurrent;        for (int j = 0; j < M_numberOfEquations; j++)        {            J[j][i] = (f1[j] - f2[j]) / (2.0 * h);        }    }    return J;}

//..// Our verification program simply instantiate several 'MyGenericContainer'// templates with the two test types above, and checks that the allocator// slot is as expected://..    int usageExample()    {        bslma::TestAllocator ta0;        bslma::TestAllocator ta1;//..// With 'MyTestTypeWithNoBslmaAllocatorTraits', the slot should never be set.//..        MyTestTypeWithNoBslmaAllocatorTraits x;        allocSlot = &ta0;        MyGenericContainer<MyTestTypeWithNoBslmaAllocatorTraits> x0(x);        ASSERT(&ta0 == allocSlot);        allocSlot = &ta0;        MyGenericContainer<MyTestTypeWithNoBslmaAllocatorTraits> x1(x, &ta1);        ASSERT(&ta0 == allocSlot);//..// With 'MyTestTypeWithBslmaAllocatorTraits', the slot should be set to the// allocator argument, or to 0 if not specified://..        MyTestTypeWithBslmaAllocatorTraits y;        allocSlot = &ta0;        MyGenericContainer<MyTestTypeWithBslmaAllocatorTraits> y0(y);        ASSERT(0 == allocSlot);        allocSlot = &ta0;        MyGenericContainer<MyTestTypeWithBslmaAllocatorTraits> y1(y, &ta1);        ASSERT(&ta1 == allocSlot);        return 0;    }

void Foam::equationReader::evalDimsY1DimCheck(    const equationReader * eqnReader,    const label index,    const label i,    const label storageOffset,    label& storeIndex,    dimensionSet& xDims,    dimensionSet sourceDims) const{    if    (        !xDims.dimensionless() && dimensionSet::debug    )    {        WarningIn("equationReader::evalDimsY1DimCheck")            << "Dimension error thrown for operation ["            << equationOperation::opName            (                operator[](index)[i].operation()            )            << "] in equation " << operator[](index).name()            << ", given by:" << token::NL << token::TAB            << operator[](index).rawText();    }    dimensionedScalar ds("temp", xDims, 1.0);    xDims.reset(y1(ds).dimensions());    operator[](index)[i].assignOpDimsFunction    (        &Foam::equationReader::evalDimsY1    );}

test_one(){    X1 x1(1);    Y1 y1(1);    f1( x1, y1 ); // in fact, it should find ambiguity, not pass this}

int main(void){	#pragma STDC FENV_ACCESS ON	double y;	float d;	int e, i, err = 0;	struct d_d *p;	for (i = 0; i < sizeof t/sizeof *t; i++) {		p = t + i;		if (p->r < 0)			continue;		fesetround(p->r);		feclearexcept(FE_ALL_EXCEPT);		y = y1(p->x);		e = fetestexcept(INEXACT|INVALID|DIVBYZERO|UNDERFLOW|OVERFLOW);		if (!checkexcept(e, p->e, p->r)) {			printf("%s:%d: bad fp exception: %s y1(%a)=%a, want %s",				p->file, p->line, rstr(p->r), p->x, p->y, estr(p->e));			printf(" got %s/n", estr(e));			err++;		}		d = ulperr(y, p->y, p->dy);		if ((!(p->x < 0) && !checkulp(d, p->r)) || (p->x < 0 && !isnan(y) && y != -inf)) {			printf("%s:%d: %s y1(%a) want %a got %a ulperr %.3f = %a + %a/n",				p->file, p->line, rstr(p->r), p->x, p->y, y, d, d-p->dy, p->dy);			err++;		}	}	return !!err;}

 double angle(CBundle* const &b) const {     double ax=x1()-x0;     double ay=y1()-y0;     double bx=b->x1()-b->x0;     double by=b->y1()-b->y0;     return vangle(ax,ay,bx,by); }

/** * returns the spherical Bessel function of the second kind * needed for continuum states /param l = order of the function (orbital angular momentum) /param rho = independent variable (rho = k * r) */double sphericalB::y(int l, double rho){  switch (l)    {    case 0:      return y0(rho);    case 1:      return y1(rho);    case 2:       return y2(rho);    case 3:       return y3(rho);    case 4:      return y4(rho);    case 5:      return y5(rho);    case 6:      return y6(rho);    case 7:      return y7(rho);    default:      cout << "no l>6 programed in sphericalB" << endl;      return 0.;    }}

void StringTest::testCompareShort(){    cxxtools::String s(L"abcd");    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abcd")            , 0);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abc")             , 1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abcxyz")          , -1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abd")             , -1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abb")             , 1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("ab")              , 1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abcd", 4)         , 0);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abcxyz", 3)       , 1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abcxyz", 4)       , -1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abd", 3)          , -1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("abb", 3)          , 1);    CXXTOOLS_UNIT_ASSERT_EQUALS(s.compare("ab", 2)           , 1);    cxxtools::String x1(L"abc");    CXXTOOLS_UNIT_ASSERT(x1 == "abc");    cxxtools::String y1(L"");    cxxtools::String y2("");    CXXTOOLS_UNIT_ASSERT(y1 == y2);    CXXTOOLS_UNIT_ASSERT(y1 == "");    CXXTOOLS_UNIT_ASSERT(y2 == "");}

int main() {    double x = 1.0;    double y = 1.0;    int i = 1;    acosh(x);    asinh(x);    atanh(x);    cbrt(x);    expm1(x);    erf(x);    erfc(x);    isnan(x);    j0(x);    j1(x);    jn(i,x);    ilogb(x);    logb(x);    log1p(x);    rint(x);    y0(x);    y1(x);    yn(i,x);#   ifdef _THREAD_SAFE    gamma_r(x,&i);    lgamma_r(x,&i);#   else    gamma(x);    lgamma(x);#   endif    hypot(x,y);    nextafter(x,y);    remainder(x,y);    scalb(x,y);    return 0;}

voidCompOutput::setWorkArea (const CompRect& workarea){    mWorkArea = workarea;    if (workarea.x () < (int) x1 ())	mWorkArea.setX (x1 ());    if (workarea.y () < (int) y1 ())	mWorkArea.setY (y1 ());    if (workarea.x2 () > (int) x2 ())	mWorkArea.setWidth (x2 () - mWorkArea.x ());    if (workarea.y2 () > (int) y2 ())	mWorkArea.setHeight (y2 () - mWorkArea.y ());}

void PointPort::drawItem(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget){	Q_UNUSED(option);	Q_UNUSED(widget);	painter->setPen(pen());	painter->setBrush(brush());	mPointImpl.drawItem(painter, x1() + mUnrealRadius, y1() + mUnrealRadius, mRadius);}

/* MapLine::dirTabPoint * Calculates and returns the end point of the 'direction tab' for * the line (used as a front side indicator for 2d map display) *******************************************************************/fpoint2_t MapLine::dirTabPoint(double tablen){	// Calculate midpoint	fpoint2_t mid(x1() + ((x2() - x1()) * 0.5), y1() + ((y2() - y1()) * 0.5));	// Calculate tab length	if (tablen == 0)	{		tablen = getLength() * 0.1;		if (tablen > 16) tablen = 16;		if (tablen < 2) tablen = 2;	}	// Calculate tab endpoint	if (front_vec.x == 0 && front_vec.y == 0) frontVector();	return fpoint2_t(mid.x - front_vec.x*tablen, mid.y - front_vec.y*tablen);}

voidCompOutput::setWorkArea (const CompRect &workarea){    mWorkArea = workarea;    if (workarea.x ()  < static_cast <int> (x1 ()))	mWorkArea.setX (x1 ());    if (workarea.y ()  < static_cast <int> (y1 ()))	mWorkArea.setY (y1 ());    if (workarea.x2 () > static_cast <int> (x2 ()))	mWorkArea.setWidth (x2 ()  - mWorkArea.x ());    if (workarea.y2 () > static_cast <int> (y2 ()))	mWorkArea.setHeight (y2 () - mWorkArea.y ());}

Type Foam::interpolation2DTable<Type>::operator()(    const scalar valueX,    const scalar valueY) const{    // Considers all of the list in Y being equal    label nX = this->size();    const table& t = *this;    if (nX == 0)    {        WarningIn        (            "Type Foam::interpolation2DTable<Type>::operator()"            "("                "const scalar, "                "const scalar"            ") const"        )            << "cannot interpolate a zero-sized table - returning zero" << endl;        return pTraits<Type>::zero;    }    else if (nX == 1)    {        // only 1 column (in X) - interpolate to find Y value        return interpolateValue(t.first().second(), valueY);    }    else    {        // have 2-D data, interpolate        // find low and high indices in the X range that bound valueX        label x0i = Xi(lessOp<scalar>(), valueX, false);        label x1i = Xi(greaterOp<scalar>(), valueX, true);        if (x0i == x1i)        {            return interpolateValue(t[x0i].second(), valueY);        }        else        {            Type y0(interpolateValue(t[x0i].second(), valueY));            Type y1(interpolateValue(t[x1i].second(), valueY));            // gradient in X            scalar x0 = t[x0i].first();            scalar x1 = t[x1i].first();            Type mX = (y1 - y0)/(x1 - x0);            // interpolate            return y0 + mX*(valueX - x0);        }    }}

line2 line2::interpolate(line2 const& l, double fraction) const{	return line2(		denormalize(fraction, x1(), l.x1()),		denormalize(fraction, y1(), l.y1()),		denormalize(fraction, x2(), l.x2()),		denormalize(fraction, y2(), l.y2())	);}

 ExecStatus MultPlusDom<VA,VB,VC>::propagate(Space& home, const ModEventDelta& med) {   if (VA::me(med) != ME_INT_DOM) {     GECODE_ES_CHECK((prop_mult_plus_bnd<VA,VB,VC>(home,*this,x0,x1,x2)));     return home.ES_FIX_PARTIAL(*this,VA::med(ME_INT_DOM));   }   IntView y0(x0.varimp()), y1(x1.varimp()), y2(x2.varimp());   return prop_mult_dom<IntView>(home,*this,y0,y1,y2); }

void test_rat2( void ){    NUPrecRational x1(10.0), y1(10.0), x2(20.0), y2(20.0), y(15.0), c;    double n,d;    c = x1 + (y-y1)*(x2-x1)/(y2-y1);    c.Dump(&n,&d);    printf( "%f/%f/n", n, d );}

floatG77_besy1_0 (const real * x){#if defined(BUILD_OS_DARWIN)  return (float) y1 ((double) *x);#else /* defined(BUILD_OS_DARWIN) */  return y1f (*x);#endif /* defined(BUILD_OS_DARWIN) */}

void MainWindow::showMes(QList<Measure> * measures){   // Item * item=(Item *)params;    ui->lcd_pulse_0->display(measures->at(0).angle);    ui->lcd_pulse_4->display(measures->at(0).angle);    ui->lcd_pulse_8->display(measures->at(0).angle);    ui->lcd_pulse_12->display(measures->at(0).angle);    ui->lcd_pulse_16->display(measures->at(0).angle);    ui->lcd_pulse_20->display(measures->at(0).angle);    ui->lcd_pulse_24->display(measures->at(0).angle);    ui->lcd_pulse_28->display(measures->at(0).angle);    customPlot=ui->widget;      QVector<double> x(101), y(101); // initialize with entries 0..100      QVector<double> x1(101), y1(101);      for(int i=0; i<8; i++)      {          x1[i] = 0;          y1[i] = 0;          x[i] = 0;          y[i] = 0;          customPlot->graph(1)->setData(x1, y1);          customPlot->graph(0)->setData(x, y);      }      int pulse=0;      int i=0;      while(measures->at(i).angle!=0)      {          x[i]=pulse;          y[i]=measures->at(i).angle;          i++; pulse+=4;      }      customPlot->graph(0)->setData(x, y);      /*      if(item->approx[0].angle!=0)      {          for (int i=0; i<8; ++i)          {              x1[i] = i*4;              y1[i] = item->approx[i].angle;          }           customPlot->graph(1)->setData(x1, y1);      }*/      /*      customPlot->yAxis->setRange(item->measures[0].angle, item->measures[0].angle+550);      ui->widget->replot();      */}

void CustomPlotRegression::setupQuadraticDemo(double * kernely,                                              int size_kernely,                                              double * kernelx,                                              int size_kernelx  ){    QCustomPlot* customPlot=m_CustomPlot;    // make top right axes clones of bottom left axes:    // generate some data:    QVector<double> x1( 0 ), y1( 0 );   // initialize with entries 0..100    customPlot->addGraph();    customPlot->graph( 0 )->setPen( QPen( Qt::red ) );    //customPlot->graph( 0 )->setSelectedPen( QPen( Qt::blue, 2 ) );    //    customPlot->graph( 0 )->setData( x1, y1 );    QVector<double> x;    QVector<double> y;    //std::cout << "****************************************************************+++" <<endl;    double maxx= DBL_MIN;    double maxy= DBL_MIN;    for (int i = 0; i < size_kernelx; i++) {        //        std::cout << kernel[i] << endl;        x.push_back(kernelx[i]);        y.push_back(kernely[i]);        if(kernelx[i] > maxx){            maxx=kernelx[i];        }        if(kernely[i] > maxy){            maxy=kernely[i];        }    }    m_CustomPlot->graph( 0 )->setData( x, y);    //    std::cout << "ok" << endl;    customPlot->graph(0)->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssDisc, 10));    customPlot->addGraph();    customPlot->graph( 1 )->setPen( QPen( Qt::green ) );    //customPlot->graph( 1 )->setSelectedPen( QPen( Qt::blue, 2 ) );    //    customPlot->graph( 1 )->setData( x1, y1 );    customPlot->graph(1)->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssDisc, 10));    // give the axes some labels:    customPlot->xAxis->setLabel( "Generation" );    customPlot->yAxis->setLabel( "Fitness" );    // set axes ranges, so we see all data:    customPlot->xAxis->setRange( 0, maxx );    customPlot->yAxis->setRange( 0, maxy);    customPlot ->setInteractions( QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables );    connect( customPlot, SIGNAL( plottableClick( QCPAbstractPlottable*, QMouseEvent* ) ), this, SLOT( graphClicked( QCPAbstractPlottable* ) ) );    for (int i = 0; i < number_of_function; ++i) {            customPlot->addGraph();    }}

void main()  {     double x, y, z;     x = j0( 2.4 );     y = y1( 1.58 );     z = jn( 3, 2.4 );     printf( "j0(2.4) = %f, y1(1.58) = %f/n", x, y );     printf( "jn(3,2.4) = %f/n", z );  }

inline complex<typename boost::tr1_detail::largest_real<T, U>::type>   pow(const complex<T>& x, const complex<U>& y){   typedef complex<typename boost::tr1_detail::largest_real<T, U>::type> result_type;   typedef typename boost::mpl::if_<boost::is_same<result_type, complex<T> >, result_type const&, result_type>::type cast1_type;   typedef typename boost::mpl::if_<boost::is_same<result_type, complex<U> >, result_type const&, result_type>::type cast2_type;   cast1_type x1(x);   cast2_type y1(y);   return std::pow(x1, y1);}