int main() { // Using our template function, we can generate functions which handles // the correct type at compile-time. double a = 1.5, b = 2.5; std::cout << "Larger of " << a << " and " << b << " is " << larger(a, b) << std::endl; int c = 1, d = 2; std::cout << "Larger of " << c << " and " << d << " is " << larger(c, d) << std::endl; long e {8L}, f {9L}; std::cout << "Larger of " << e << " and " << f << " is " << larger(e, f) << std::endl; std::cout << "Larger of " << e << " and " << f << " is " << *larger(&e, &f) << std::endl; std::vector<unsigned int> values { 2u, 3u, 5u, 7u, 11u, 13u, 17u, 19u, 6u }; std::cout << "Largest element is " << larger(values) << std::endl; // compiler creates function that accepts arguments of type double // and returns a result of type double std::cout << "Larger of 1.5 and 2.5 is " << larger<double, double>(1.5, 2.5) << std::endl; double ans = larger<double, int>(5, 25); std::cout << "Larger of 5 and 25 is " << ans << std::endl; return 0; }
double descriptor34::ClebshGordan(double l, double m, double l1, double m1, double l2, double m2){ double j = l, j1 = l1, j2 = l2; if (!equal(m,(m1 + m2))) return 0; double min_possible, max_possible; min_possible = abs_double(j1 - j2); max_possible = j1 + j2; if (larger(j, max_possible)) return 0; if (larger(min_possible, j)) return 0; double first_sqrt = sqrt((2 * j + 1) * factorial[lrint(j + j1 - j2)] * factorial[lrint(j - j1 + j2)] * factorial[lrint(j1 + j2 - j)] / factorial[lrint(j1 + j2 + j + 1)]); double second_sqrt = sqrt(factorial[lrint(j + m)] * factorial[lrint(j - m)] * factorial[lrint(j1 - m1)] * factorial[lrint(j1 + m1)] * factorial[lrint(j2 - m2)] * factorial[lrint(j2 + m2)]); int maxk = min(lrint(j1 + j2 - j), lrint(j1 - m1)); maxk = min(maxk, lrint(j2 + m2)); int mink = 0; mink = max(mink, lrint(j2 - j - m1)); mink = max(mink, lrint(j1 + m2 - j)); double sum = 0; double a; for (int k = mink; k <= maxk; k = k + 1){ a = factorial[k] * factorial[lrint(j1 + j2 - j) - k] * factorial[lrint(j1 - m1) - k] * factorial[lrint(j2 + m2) - k] * factorial[lrint(j - j2 + m1) + k] * factorial[lrint(j - j1 - m2) + k]; a = 1.0/a; if (k % 2 == 1) a = -a; sum = sum + a; } return sum * first_sqrt * second_sqrt; }
int main() { int largest; largest = larger(7, 8); printf("Largest is %i.\n", largest); largest = larger(3, 1); printf("Largest is %i.\n", largest); return 0; }
/** *the implement of sort *empty row should be put to the bottom of sheet */ bool EasyTableCompare::operator ()(const QStringList& row1, const QStringList& row2) const { for(int i = 0;i<KeyCount;i++) { int column = keys[i]; if(column >= 0) { if(row1[column] != row2[column]) { if(row1[column] != "" && row2[column] != "") { if(ascending[i])//if sort by ascending { return smaller(row1[column],row2[column]); //return true if row1[column] < row2[column] } else { return larger(row1[column],row2[column]); } }//end if(row1[column] != row2[column]) else //the empty cell should be at the bottom of unempty cell { if(row1[column] == "") return false; else return true; }//end else }//end if row1[column] != row2[column] }//end if column != -1 }//end for return false; }
void ch8re8(void) { box a = {"Kevin", 212,33,13}; box b = {"Ben", 12,32,43}; cal_vol(a); cal_vol(b); std::cout << larger(a,b); }
void f() { vector<int> vx; vector<int> vy; // read vx and vy from input larger(vx,vy); // ... }
FUNC_DECL void operator()( mass_point_type &m , const point_type &bound_vel ) const { point_type &p = m.coor; if( larger( m_bound , p[which] ) ) { p[which] = 2.0 * m_bound - p[which]; m.vel[which] = -m.vel[which]; m.vel += bound_vel; } }
/* * used to subtract two numbers with the same sign */ int* subtract (int* input1, int* input2, int base) { if (larger(input1,input2)){ return subtractLarger(input1, input2, base); } else { int* res = subtractLarger(input2, input1, base); //exchange input1 and input2, note the result is negative int sign = -2; //negative result res[bignum_length(res)] = sign; return res; } }
int bitwiseRange(int m, int n) { int top = larger(m, n); int bottom = smaller(m, n); int tracker = top; int product; while(bottom < top) { top = top&(top-1); product = top; } return product; }
int main() { int i, j; char a[110], b[110]; strcpy( fibo[1], "1" ); strcpy( fibo[2], "2" ); for ( i = 3; i < 505; ++i ) { add( fibo[i - 2], fibo[i - 1], fibo[i] ); } while ( scanf( "%s %s", a, b ) && !( a[0] == '0' && b[0] == '0' ) ) { i = 1; while ( larger( a, fibo[i] ) == 1 ) { ++i; } j = 0; while ( larger( b, fibo[i] ) != -1 ) { ++j; ++i; } printf( "%d\n", j ); } return 0; }
int insertBook(Book b[],int n,Book b1) /*向b数组中依学号递增插入一个元素s*/ { int i; sortBook(b,n,1); /*先按ISBN排序*/ for (i=n-1;i>=0;i--) /*按学号从小到大有序*/ { if (!larger(b[i],b1,1)) /*如果b大于当前元素b[i],则退出循环*/ break; b[i+1]=b[i]; /*否则元素b[i]后移一个位置*/ } b[i+1]=b1; /*在下标i+1处插入元素b1*/ n++; /*元素个数增加1*/ return n; /*返回现有元素个数*/ }
void sortBook(Book b[],int n,int condition) /*选择法排序,按condition条件由小到大排序*/ { int i,j,minpos; /*minpos用来存储本趟最小元素所在的下标*/ Book t; for (i=0;i<n-1;i++) /*控制循环的n-1趟*/ { minpos=i; for (j=i+1;j<n;j++) /*寻找本趟最小元素所在的下标*/ if (larger(b[minpos],b[j],condition)) minpos=j; if (i!=minpos) /*保证本趟最小元素到达下标为i的位置*/ { t=b[i]; b[i]=b[minpos]; b[minpos]=t; } } }
void sortPla(Player pla[],int n,int condition) /*选择法排序,按condition条件由小到大排序*/ { int i,j,minpos; /*minpos用来存储本趟最小元素所在的下标*/ Player p; for (i=0;i<n-1;i++) /*控制循环的n-1趟*/ { minpos=i; for (j=i+1;j<n;j++) /*寻找本趟最小元素所在的下标*/ if (larger(pla[minpos],pla[j],condition)) minpos=j; if (i!=minpos) /*保证本趟最小元素到达下标为i的位置*/ { p=pla[i]; pla[i]=pla[minpos]; pla[minpos]=p; } } }
int insertPla(Player pla[],int n,Player p) /*向pla数组中依编号递增插入一个元素s*/ { int i; sortPla(pla,n,1); /*先按编号排序*/ for (i=0;i<n;i++) { if (equal(pla[i],p,1)) /*编号相同不允许插入,保证编号的唯一性*/ { printf("this record exist,can not insert again!\n"); return n; } } for (i=n-1;i>=0;i--) /*按编号从小到大有序*/ { if (!larger(pla[i],p,1)) /*如果p大于当前元素pla[i],则退出循环*/ break; pla[i+1]=pla[i]; /*否则元素pla[i]后移一个位置*/ } pla[i+1]=p; /*在下标i+1处插入元素s*/ n++; /*元素个数增加1*/ return n; /*返回现有元素个数*/ }
int insertBk(Book bk[],int n,Book b) /*向bk数组中依书的编号递增插入一个元素bk*/ { int i; sortBk(bk,n,1); /*先按书编号排序*/ for (i=0;i<n;i++) { if (equal(bk[i],b,1)) /*书编号相同不允许插入,保证书编号的唯一性*/ { printf("this record exist,can not insert again!\n"); return n; } } for (i=n-1;i>=0;i--) /*按学号从小到大有序*/ { if (!larger(bk[i],b,1)) /*如果b大于当前元素bk[i],则退出循环*/ break; bk[i+1]=bk[i]; /*否则元素bk[i]后移一个位置*/ } bk[i+1]=b; /*在下标i+1处插入元素s*/ n++; /*元素个数增加1*/ return n; /*返回现有元素个数*/ }
ListNode* AddLists(ListNode* l1, ListNode* l2) { if (!l1 && !l2) return NULL; else if (!l1) return l2; else if (!l2) return l1; if (larger(l2, l1)) swap(l1, l2); bool sign = true; int plus = 1; if (l1->val == '-') { sign = false; plus = -plus; } if (l2->val == '-') { plus = -plus;} l1 = l1->next; l2 = l2->next; ListNode* head = NULL; ListNode* prev = NULL; int carry = 0; while (l1 || l2) { int tmp=l1->val-'0'+carry+ plus*((l2) ? l2->val-'0' : 0); if (tmp < 0) { carry = -1; tmp = tmp+10; } else { carry = tmp/10; tmp = tmp%10; } ListNode* cur= new ListNode(tmp+'0'); if (!prev) head = cur; else prev->next = cur; prev = cur; l1 = l1->next; if (l2) l2 = l2->next; } assert(carry >= 0); if (carry) prev->next = new ListNode('1'); ListNode* s = new ListNode(((sign) ? '+': '-')); s->next = head; head = s; removeLeadingZeros(head); return head; }
int main(){ int greatest = larger(100, 1000); printf("%i is the greatest!\n", greatest); return 0; }
wxSize wxRibbonPanel::DoGetNextLargerSize(wxOrientation direction, wxSize relative_to) const { if(m_expanded_panel != NULL) { // Next size depends upon children, who are currently in the // expanded panel return m_expanded_panel->DoGetNextLargerSize(direction, relative_to); } if(IsMinimised(relative_to)) { wxSize current = relative_to; wxSize min_size = GetMinNotMinimisedSize(); switch(direction) { case wxHORIZONTAL: if(min_size.x > current.x && min_size.y == current.y) return min_size; break; case wxVERTICAL: if(min_size.x == current.x && min_size.y > current.y) return min_size; break; case wxBOTH: if(min_size.x > current.x && min_size.y > current.y) return min_size; break; default: break; } } if(m_art != NULL) { wxClientDC dc((wxRibbonPanel*) this); wxSize child_relative = m_art->GetPanelClientSize(dc, this, relative_to, NULL); wxSize larger(-1, -1); if(GetSizer()) { // We could just let the sizer expand in flow direction but see comment // in IsSizingContinuous() larger = GetPanelSizerBestSize(); // and adjust for page in non flow direction if(m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL) { if(larger.x != child_relative.x) larger.x = child_relative.x; } else if(larger.y != child_relative.y) { larger.y = child_relative.y; } } else if(GetChildren().GetCount() == 1) { // Simple (and common) case of single ribbon child wxWindow* child = GetChildren().Item(0)->GetData(); wxRibbonControl* ribbon_child = wxDynamicCast(child, wxRibbonControl); if(ribbon_child != NULL) { larger = ribbon_child->GetNextLargerSize(direction, child_relative); } } if(larger.IsFullySpecified()) // Use fallback if !(sizer/child = 1) { if(larger == child_relative) { return relative_to; } else { return m_art->GetPanelSize(dc, this, larger, NULL); } } } // Fallback: Increase by 25% (equal to a prior or subsequent 20% decrease) // Note that due to rounding errors, this increase may not exactly equal a // matching decrease - an ideal solution would not have these errors, but // avoiding them is non-trivial unless an increase is by 100% rather than // a fractional amount. This would then be non-ideal as the resizes happen // at very large intervals. wxSize current(relative_to); if(direction & wxHORIZONTAL) { current.x = (current.x * 5 + 3) / 4; } if(direction & wxVERTICAL) { current.y = (current.y * 5 + 3) / 4; } return current; }
int main(int argc, char const *argv[]) { int greatest = larger(100, 120); printf("%i is the greatest !\n", greatest); return 0; }
void CollisionApp::DoPhysics(double a_dt) { m_player.angle += (m_dTurn * float(a_dt)); float epsilon = 0.0001f; if (abs(m_player.speed) > epsilon) { vec3 v(cos(m_player.angle), sin(m_player.angle), 0.0f); float dt = float(a_dt); float tTemp(0.0f); for (int i = 0; i < 2; i++) { bool willCollide = false; float closestTime(FLT_MAX); enum { E_None, E_Line, E_Disk, E_Point }; int colType = E_None; size_t index; for (size_t i = 0; i < m_boundaryLines.size(); i++) { bool hitThis = WillCollide(dt, m_player.disk, m_player.speed * v, m_boundaryLines[i].line, m_boundaryLines[i].length, tTemp); if (hitThis && tTemp < closestTime) { closestTime = tTemp; index = i; colType = E_Line; willCollide = true; } } //Weird stuff happens if we don't give boundary lines a priority over boundary points if (colType != E_Line) { for (size_t i = 0; i < m_boundaryPoints.size(); i++) { bool hitThis = WillCollide(dt, m_player.disk, m_player.speed * v, m_boundaryPoints[i], tTemp); if (hitThis && tTemp < closestTime) { closestTime = tTemp; index = i; colType = E_Point; willCollide = true; } } } if (!willCollide) { m_player.disk.SetCenter(m_player.disk.Center() + dt * m_player.speed * v); break; } else { switch (colType) { case E_Line: { //Increase the disk size so we don't get so close, to account for floating point error Disk larger(m_player.disk); larger.SetRadius(m_player.disk.Radius() + epsilon); Dg::R2::FPCDiskLine<float> fpc; Dg::R2::FPCDiskLine<float>::Result result_fpc = fpc(larger, m_player.speed * v, m_boundaryLines[index].line, vec3::ZeroVector()); //Move to almost on the target m_player.disk.SetCenter(m_player.disk.Center() + (result_fpc.t * m_player.speed * v)); //Find new velocity vector v = (v.Dot(m_boundaryLines[index].line.Direction())) * m_boundaryLines[index].line.Direction(); break; } case E_Point: { //Increase the disk size so we don't get so close, to account for floating point error Disk larger(m_player.disk); larger.SetRadius(m_player.disk.Radius() + epsilon); Dg::R2::FPCPointDisk<float> fpc; Dg::R2::FPCPointDisk<float>::Result result_fpc = fpc(larger, m_player.speed * v, m_boundaryPoints[index], vec3::ZeroVector()); //Move to almost on the target m_player.disk.SetCenter(m_player.disk.Center() + (result_fpc.t * m_player.speed * v)); //Find new velocity vector vec3 v_dp = m_boundaryPoints[index] - m_player.disk.Center(); v_dp.Normalize(); v = v.Dot(-v_dp.Perpendicular()) * -v_dp.Perpendicular(); break; } } //adjust dt dt -= closestTime; } } } }