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;
}
}
}
}
