void CScanLineZBufferView::CalcModelInfo()
{
// 计算模型的中心坐标
m_centerPoint.x = m_centerPoint.y = m_centerPoint.z = 0;
CScanLineZBufferDoc *pDoc = GetDocument();
Point min_xyz, max_xyz;
auto first_point = (pDoc->m_mesh).point((pDoc->m_mesh).vertices_begin().handle());
min_xyz.x = max_xyz.x = first_point.data()[0];
min_xyz.y = max_xyz.y = first_point.data()[1];
min_xyz.z = max_xyz.z = first_point.data()[2];
for (auto vertex_it = (pDoc->m_mesh).vertices_begin(); vertex_it != (pDoc->m_mesh).vertices_end(); ++vertex_it)
{
auto point = (pDoc->m_mesh).point(vertex_it.handle());
auto x = point.data()[0], y = point.data()[1], z = point.data()[2];
m_centerPoint.x += x;
m_centerPoint.y += y;
m_centerPoint.z += z;
min_xyz.x = mmin(min_xyz.x, x);
min_xyz.y = mmin(min_xyz.y, y);
min_xyz.z = mmin(min_xyz.z, z);
max_xyz.x = mmax(max_xyz.x, x);
max_xyz.y = mmax(max_xyz.y, y);
max_xyz.z = mmax(max_xyz.z, z);
}
int n_verteice = (pDoc->m_mesh).n_vertices();
m_centerPoint.x /= n_verteice;
m_centerPoint.y /= n_verteice;
m_centerPoint.z /= n_verteice;
double vec[] = { max_xyz.x - min_xyz.x, max_xyz.y - min_xyz.y, max_xyz.z - min_xyz.z };
// 计算模型的尺寸
m_modelScale = sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
}
void Quant(int *coeff, int *qcoeff, int QP, int Mode)
{
int i;
int level;
if (QP) {
if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) { /* Intra */
qcoeff[0] = mmax(1,mmin(254,coeff[0]/8));
for (i = 1; i < 64; i++) {
level = (abs(coeff[i])) / (2*QP);
qcoeff[i] = mmin(127,mmax(-127,sign(coeff[i]) * level));
}
}
else { /* non Intra */
for (i = 0; i < 64; i++) {
level = (abs(coeff[i])-QP/2) / (2*QP);
qcoeff[i] = mmin(127,mmax(-127,sign(coeff[i]) * level));
}
}
}
else {
/* No quantizing.
Used only for testing. Bitstream will not be decodable
whether clipping is performed or not */
for (i = 0; i < 64; i++) {
qcoeff[i] = coeff[i];
}
}
return;
}
void HorizEdgeFilter (unsigned char *rec, int width, int height, Pict * pic, int chr)
{
int i, j;
int delta, d1, d2;
int mbc, mbr, do_filter;
int QP;
int bquant[] = {5, 6, 7, 8};
int mbr_above;
/* horizontal edges */
for (j = 8; j < height; j += 8)
{
for (i = 0; i < width; i++)
{
if (!chr)
{
mbr = j >> 4;
mbc = i >> 4;
mbr_above = (j - 8) >> 4;
} else
{
mbr = j >> 3;
mbc = i >> 3;
mbr_above = mbr - 1;
}
do_filter = coded_map[mbr + 1][mbc + 1] || coded_map[mbr_above + 1][mbc + 1];
if (do_filter)
{
if (pic->PB)
{
QP = coded_map[mbr + 1][mbc + 1] ?
mmin (31, bquant[pic->BQUANT] * quant_map[mbr + 1][mbc + 1] / 4) :
mmin (31, bquant[pic->BQUANT] * quant_map[mbr_above + 1][mbc + 1] / 4);
} else
QP = coded_map[mbr + 1][mbc + 1] ? quant_map[mbr + 1][mbc + 1] : quant_map[mbr_above + 1][mbc + 1];
if (modified_quantization && chr)
{
QP=MQ_chroma_QP_table[QP];
}
delta = (int) (((int) (*(rec + i + (j - 2) * width)) +
(int) (*(rec + i + (j - 1) * width) * (-4)) +
(int) (*(rec + i + (j) * width) * (4)) +
(int) (*(rec + i + (j + 1) * width) * (-1))) / 8.0);
d1 = sign (delta) * mmax (0, abs (delta) - mmax (0, 2 * (abs (delta) - STRENGTH[QP - 1])));
d2 = mmin (abs (d1 / 2), mmax (-abs (d1 / 2), (int) (((*(rec + i + (j - 2) * width) -
*(rec + i + (j + 1) * width))) / 4)));
*(rec + i + (j + 1) * width) = (int) (*(rec + i + (j + 1) * width)) + d2;
*(rec + i + (j) * width) =
mmin (255, mmax (0, (int) (*(rec + i + (j) * width)) - d1));
*(rec + i + (j - 1) * width) =
mmin (255, mmax (0, (int) (*(rec + i + (j - 1) * width)) + d1));
*(rec + i + (j - 2) * width) = (int) (*(rec + i + (j - 2) * width)) - d2;
}
}
/* Answer the address of minHeapSize rounded up to page size bytes of memory. */
usqInt
sqAllocateMemory(usqInt minHeapSize, usqInt desiredHeapSize)
{
char *hint, *address, *alloc;
unsigned long alignment, allocBytes;
if (pageSize) {
fprintf(stderr, "sqAllocateMemory: already called\n");
exit(1);
}
pageSize = getpagesize();
pageMask = ~(pageSize - 1);
hint = sbrk(0);
alignment = mmax(pageSize,1024*1024);
address = (char *)(((usqInt)hint + alignment - 1) & ~(alignment - 1));
alloc = sqAllocateMemorySegmentOfSizeAboveAllocatedSizeInto
(roundUpToPage(desiredHeapSize), address, &allocBytes);
if (!alloc) {
fprintf(stderr, "sqAllocateMemory: initial alloc failed!\n");
exit(errno);
}
return (usqInt)alloc;
}
int main() {
int N, M;
int L, R;
int i, k;
scanf("%d %d", &N, &M);
for(i=0; i<N; i++) {
scanf("%d", profit+i);
}
// 约定Pk为以k为结尾的最长perfect串
// 当前perfect串中出现的数，在app[]中对应位置为true
perfect[0] = 1;
repeat[0] = 0;
Appear(profit[0]) = true;
for(k=1; k<N; k++) {
// 如果第k个数在Pk-1中未出现，将第k个数加入Pk-1仍然是个perfect串，那么|Pk| = |Pk-1|+1
if( !Appear(profit[k]) ) {
Appear(profit[k]) = true;
perfect[k] = perfect[k-1]+1;
repeat[k] = repeat[k-1]; // repeat值和Pk-1相同
}
// 否则，从Pk-1开头开始找，一直找到和第k个数相同的那个数，截掉前面的那一段
else {
i = k-perfect[k-1];
while( profit[i] != profit[k] ) {
Appear(profit[i]) = false;
i ++;
}
perfect[k] = k-i; // 新的串长度
repeat[k] = k; // repeat值为自己
}
}
int ret;
for(k=0; k<M; k++) {
ret = 0;
scanf("%d %d", &L, &R);
while( 1 ) {
// 结果大于当前范围，可提前退出
if( R-L+1 <= ret ) {
break;
}
ret = mmax(ret, mmin(perfect[R], R-L+1));
// |P(repeat[R])| < |P(repeat[R]+1)| < ... < |P(R)|, 所以直接跳到P(repeat[R]-1)处
R = repeat[R]-1;
}
printf("%d\n", ret);
}
return 1;
}
double SDFFelementManager::extract_end_time(){
std::map<std::string, std::vector<SDFFsequenceElement*> >::const_iterator i;
double et=0;
// go through all elements and always store the maximum end_time ...
for (i=elements.begin(); i!=elements.end(); ++i) {
if (i->second.size()>0) {
for (size_t j=0; j<i->second.size(); j++) {
double eet=i->second[j]->extract_real_t_end();
et=mmax(et, eet);
}
}
}
return et;//+sample_timestep*2.0;
};
void datatable2::resize(unsigned long newx, unsigned long newy){
if (newy<=line_size) {
line_count=newy;
} else {
if (column_size>0) for (unsigned long x=0; x<column_size; x++) {
register void *value = realloc(data[x], (unsigned long)(newy*resize_factor)*sizeof(datatable2_value));
if (value == NULL)
DATATABLE2_ERROR(DATATABLE2_ERROR_VMEM_NUM, DATATABLE2_ERROR_VMEM_MESSAGE, "datatable2.resize("+inttostr(newx)+", "+inttostr(newy)+")");
data[x]=(datatable2_value*)value;
for (unsigned long y=line_count; y<(unsigned long)(newy*resize_factor); y++) {
data[x][y].value=0;
data[x][y].empty=true;
}
}
line_size=(unsigned long)(newy*resize_factor);
line_count=newy;
}
if (newx<=column_size) {
column_count=newx;
} else {
if (column_size==0) {
register void *value = malloc((unsigned long)(mmax(newx,1)*resize_factor)*sizeof(datatable2_value*)); // get a bit more (+20%) of memory for lines
if (value == NULL)
DATATABLE2_ERROR(DATATABLE2_ERROR_VMEM_NUM, DATATABLE2_ERROR_VMEM_MESSAGE, "datatable2.resize("+inttostr(newx)+", "+inttostr(newy)+")");
data=(datatable2_value**)value;
} else {
register void *value = realloc(data, (unsigned long)(newx*resize_factor)*sizeof(datatable2_value*)); // get a bit more (+20%) of memory for lines
if (value == NULL)
DATATABLE2_ERROR(DATATABLE2_ERROR_VMEM_NUM, DATATABLE2_ERROR_VMEM_MESSAGE, "datatable2.resize("+inttostr(newx)+", "+inttostr(newy)+")");
data=(datatable2_value**)value;
}
for (unsigned long i=column_size; i<(unsigned long)(newx*resize_factor); i++) {
register void *value = malloc(line_size*sizeof(datatable2_value));
if (value == NULL)
DATATABLE2_ERROR(DATATABLE2_ERROR_VMEM_NUM, DATATABLE2_ERROR_VMEM_MESSAGE, "datatable2.resize("+inttostr(newx)+", "+inttostr(newy)+")");
data[i]=(datatable2_value*)value;
for (unsigned long y=0; y<line_size; y++) {
data[i][y].value=0;
data[i][y].empty=true;
}
}
column_count=newx;
column_size=(unsigned long)(newx*resize_factor);
}
resize_titles();
}
void InterPolynomial::updateM(Vector newPoint, double valueF)
{
//not tested
unsigned i=nPtsUsed;
double sum=0,a;
Polynomial *pp=NewtonBasis;
Vector *xx=NewtonPoints;
while (i--)
{
a=newPoint.euclidianDistance(xx[i]);
sum+=condorAbs(pp[i]( newPoint ))*a*a*a;
}
M=mmax(M, condorAbs((*this)(newPoint)-valueF)/sum);
nUpdateOfM++;
}
void UnitList::recreateLists(const VC2 &size)
{
VC2 mmin(-size.x, -size.y);
VC2 mmax( size.x, size.y);
LinkedListIterator iter(allUnits);
while (iter.iterateAvailable())
{
Unit *u = (Unit *)iter.iterateNext();
if (u->getUnitListEntity() != NULL)
{
delete u->getUnitListEntity();
u->setUnitListEntity(NULL);
}
}
impl->tree.reset(new UnitQTree(mmin, mmax));
iter = LinkedListIterator(allUnits);
while (iter.iterateAvailable())
{
Unit *u = (Unit *)iter.iterateNext();
//assert(u->getUnitListEntity() != NULL);
//delete u->getUnitListEntity();
float radius = UNIT_QTREE_RADIUS_HACK;
// grow the radius for non-boned units only
// (as boned units may have 15m radius or such because of changing animations)
if (u->getUnitType()->getBonesFilename() == NULL)
{
if (u->getVisualObject() != NULL
&& u->getVisualObject()->getStormModel() != NULL)
{
float radius2 = u->getVisualObject()->getStormModel()->GetRadius();
if (radius2 > radius) radius = radius2;
}
}
u->setUnitListEntity(new UnitListEntity());
u->getUnitListEntity()->entity = impl->tree->insert(u, u->getPosition(), radius);
u->getUnitListEntity()->lastUpdatePosition = u->getPosition();
}
}
int InterPolynomial::findAGoodPointToReplace(int excludeFromT,
double rho, Vector pointToAdd, double *maxd)
{
//not tested
// excludeFromT is set to k if not success from optim and we want
// to be sure that we keep the best point
// excludeFromT is set to -1 if we can replace the point x_k by
// pointToAdd(=x_k+d) because of the success of optim.
// chosen t: the index of the point inside the newtonPoints
// which will be replaced.
Vector *xx=NewtonPoints;
Vector XkHat;
if (excludeFromT>=0) XkHat=xx[excludeFromT];
else XkHat=pointToAdd;
int t=-1, i, N=nPtsUsed;
double a, aa, maxa=-1.0, maxdd=0;
Polynomial *pp=NewtonBasis;
// if (excludeFromT>=0) maxa=1.0;
for (i=0; i<N; i++)
{
if (i==excludeFromT) continue;
aa=XkHat.euclidianDistance(xx[i]);
if (aa==0.0) return -1;
a=aa/rho;
// because of the next line, rho is important:
a=mmax(a*a*a,1.0);
a*=condorAbs(pp[i] (pointToAdd));
if (a>maxa)
{
t=i; maxa=a; maxdd=aa;
}
}
if (maxd) *maxd=maxdd;
return t;
}
/* For q=8, a "speedy" version is integrated */
int QuantAndFindCBP(int *coeff, int *qcoeff, int QP, int Mode, int CBP_Mask)
{
int i;
int level;
int tempje;
int CBP = 0;
if (Mode == MODE_INTRA) { /* Intra */
qcoeff[0] = mmax(1,mmin(254,coeff[0] >> 3)); /* was: /8 */
if(QP == 8) {
for(i = 1; i < 64; i++) {
level = (abs(coeff[i])) >> 4;
qcoeff[i] = mmin(127, mmax(-127,sign(coeff[i]) * level));
if(qcoeff[i])
CBP = CBP_Mask;
}
} else { /* QP != 8 */
for(i = 1; i < 64; i++) {
/*
fills the virtual memory with anonymous PROT_NONE mmaps,
returns the mappings in *p and *n in decreasing size order,
the return value is the number of mappings or -1 on failure.
*/
int t_vmfill(void **p, size_t *n, int len)
{
int fd = open("/dev/zero", O_RDWR);
size_t start = SIZE_MAX/2 + 1;
size_t m;
void *q;
int i;
for (i=0;;i++) {
m = mmax(fd, &start);
if (!m)
break;
q = mmap(0, m, PROT_NONE, MAP_PRIVATE, fd, 0);
if (q == MAP_FAILED)
return -1;
if (i < len) {
p[i] = q;
n[i] = m;
}
}
return i;
}
int
main(){
double out[8][8];
double out2[8][8];
double out3[8][8];
double in[8][8];
double in2[8][8];
for(int y=0;y<N;y++)
for(int x=0;x<N;x++){
mzero(in);
in[y][x]=1;
idct(in,out);
for(int iy=0;iy<N;iy++)
for(int ix=0;ix<N;ix++){
if(out[iy][ix]>=0)
in2[iy][ix]=255;
else
in2[iy][ix]=0;
}
dct(in2,out2);
if(x==0&&y==0)
out3[y][x]=out2[0][0];
else
out3[y][x]=mmax(out2);
}
// mmap(out3,(1.0/4)*);
mmap(out3,round);
mprint(out3);
return true;
}
void DDI_ARR_select_local(DDI_Patch *dAPatch, DDI_ARR_Element *element) {
DDA_Index *Index = gv(dda_index);
int dA = dAPatch->handle;
double *dALocal;
int op = dAPatch->oper;
int dALdaLocal, dAiLocal, dAjLocal, dAmLocal, dAnLocal;
/* A segment dimensions */
dALdaLocal = Index[dA].ihi - Index[dA].ilo + 1;
dAiLocal = dAPatch->ilo - Index[dA].ilo;
dAjLocal = dAPatch->jlo - Index[dA].jlo;
dAmLocal = dAPatch->ihi - dAPatch->ilo + 1;
dAnLocal = dAPatch->jhi - dAPatch->jlo + 1;
# if defined USE_SYSV
if(USING_DATA_SERVERS()) DDI_Fence_check(dA);
# endif
DDI_Acquire(Index, dA, DDI_READ_ACCESS, (void**)&dALocal);
switch(op) {
case DDI_ARR_MIN:
mmin(dALocal, dALdaLocal, dAiLocal, dAjLocal, dAmLocal, dAnLocal, &(element->alpha), element->index);
break;
case DDI_ARR_MAX:
mmax(dALocal, dALdaLocal, dAiLocal, dAjLocal, dAmLocal, dAnLocal, &(element->alpha), element->index);
break;
} /* switch */
/* adjust element indices to global values */
element->index[0] += Index[dA].ilo;
element->index[1] += Index[dA].jlo;
DDI_Release(Index, dA, DDI_READ_ACCESS);
}
// 建立分类多边形边和分类边表
void ScanLineZBufferCore::BuildPolygonAndEdgeTable()
{
int width = m_viewport[2];
int height = m_viewport[3];
m_polygonTable.resize(height, std::vector<PolygonTableElem>());
m_edgeTable.resize(height, std::vector<EdgeTableElem>());
for (auto i = 0; i < height; i++)
{
m_polygonTable[i].clear();
m_edgeTable[i].clear();
}
PolygonTableElem cpte;
// 遍历每个多边形，加入到多边形表和边表
for (auto f_it = pMesh->faces_begin(); f_it != pMesh->faces_end(); ++f_it)
{
//std::cout << "当前多边形 " << f_it->idx() << std::endl;
// 遍历多边形的每条边，构造分类边表
for (auto h_it = pMesh->fh_begin(f_it.handle()); h_it != pMesh->fh_end(f_it.handle()); ++h_it)
{
EdgeTableElem cete;
cete.id = f_it->idx();
auto point_a_idx = (pMesh->from_vertex_handle(h_it.handle())).idx();
auto point_b_idx = (pMesh->to_vertex_handle(h_it.handle())).idx();
// 判断边上两个点谁的y值更大
int max_idx, min_idx;
if (m_projectionVertex[point_a_idx].y > m_projectionVertex[point_b_idx].y)
{
max_idx = point_a_idx;
min_idx = point_b_idx;
}
else
{
max_idx = point_b_idx;
min_idx = point_a_idx;
}
// 设置为边的上端点坐标
cete.x = m_projectionVertex[max_idx].x;
// 设置边跨越的扫描线数目 和 两点x方向差， 实质为 -cet.dy/cet.dx
cete.dy = m_projectionVertex[max_idx].y - m_projectionVertex[min_idx].y;
// 略过水平线不处理
if (abs(cete.dy) < 1e-8) continue;
cete.dx = -(m_projectionVertex[min_idx].x - m_projectionVertex[max_idx].x) / (m_projectionVertex[min_idx].y - m_projectionVertex[max_idx].y);
// 添加到分类边表
// //std::cout << logTime() << " " << convertToInt(m_projectionVertex[max_idx].y) << std::endl;
m_edgeTable[convertToInt(m_projectionVertex[max_idx].y)].push_back(cete);
//std::cout << ">>>> 加入边" << h_it->idx() << std::endl;
}
// 求当前多边形的Y的最大最小值
double min_y, max_y;
// 获取多边形上的一个顶点，初始化多边形Y的最大最小值
min_y = max_y = m_projectionVertex[(pMesh->fv_begin(f_it.handle()))->idx()].y;
// 取出当前多边形上三个点，求平面a,b,c,d
std::vector<Point> poly_point;
// 求出当前多边形的Y的最大最小值
for (auto v_it = pMesh->fv_begin(f_it.handle()); v_it != pMesh->fv_end(f_it.handle()); ++v_it)
{
auto point = m_projectionVertex[v_it->idx()];
// //std::cout << logTime() << " 点坐标" << point.y << std::endl;
poly_point.push_back(point);
min_y = mmin(min_y, point.y);
max_y = mmax(max_y, point.y);
}
// if (poly_point.size() < 3) //std::cout << logTime() << " 多边形上点的数量少于3" << std::endl;
// 求ax+by+cz+d=0，设置分类多边形参数
cpte.a = (poly_point[0].y - poly_point[1].y)*(poly_point[0].z - poly_point[2].z)
- (poly_point[0].y - poly_point[2].y)*(poly_point[0].z - poly_point[1].z);
cpte.b = (poly_point[0].x - poly_point[2].x)*(poly_point[0].z - poly_point[1].z)
- (poly_point[0].z - poly_point[2].z)*(poly_point[0].x - poly_point[1].x);
cpte.c = (poly_point[0].x - poly_point[1].x)*(poly_point[0].y - poly_point[2].y)
- (poly_point[0].x - poly_point[2].x)*(poly_point[0].y - poly_point[1].y);
cpte.d = -cpte.a*poly_point[0].x - cpte.b*poly_point[0].y - cpte.c*poly_point[0].z;
//std::cout << ">>>> 平面方程参数" << cpte.a << " " << cpte.b << " " << cpte.c << " " << cpte.d << std::endl;
// 设置多边形的id
cpte.id = f_it->idx();
// 设置多边形的颜色
cpte.color.r = (rand() % 20) + 235;
cpte.color.g = (rand() % 20) + 145;
cpte.color.b = 0;
// 加入到分类多边形表
//std::cout << std::endl;
cpte.dy = convertToInt(max_y) - convertToInt(min_y);
m_polygonTable[convertToInt(max_y)].push_back(cpte);
}
}
//------------------------------------------------------------------
// Storm3D_Mesh_CollisionTable::ReBuild
//------------------------------------------------------------------
void Storm3D_Mesh_CollisionTable::ReBuild(Storm3D_Mesh *mesh)
{
// TEMP!!!
//return;
int memory_before = 0; //frozenbyte::debug::Debug_MemoryManager::amountMemoryInUse();
// Set owner
owner=mesh;
// Allocate memory for collision table
delete tree;
tree = 0;
if(!owner->vertexes || !owner->faces[0])
return;
face_amount=owner->face_amount[0];
if (owner->collision_faces != -1)
face_amount = owner->collision_faces;
SAFE_DELETE_ARRAY(faces);
faces = new CollisionFace[face_amount];
VC2 mmin(10000000.f, 10000000.f);
VC2 mmax(-10000000.f, -10000000.f);
// Create collision table
for(int fi = 0; fi < face_amount; ++fi)
{
// Set vertexes
faces[fi].vertex0=owner->vertexes[owner->faces[0][fi].vertex_index[0]].position;
faces[fi].vertex1=owner->vertexes[owner->faces[0][fi].vertex_index[1]].position;
faces[fi].vertex2=owner->vertexes[owner->faces[0][fi].vertex_index[2]].position;
// Create edges
faces[fi].e01=owner->vertexes[owner->faces[0][fi].vertex_index[1]].position-owner->vertexes[owner->faces[0][fi].vertex_index[0]].position;
faces[fi].e02=owner->vertexes[owner->faces[0][fi].vertex_index[2]].position-owner->vertexes[owner->faces[0][fi].vertex_index[0]].position;
VC3 e12=owner->vertexes[owner->faces[0][fi].vertex_index[2]].position-owner->vertexes[owner->faces[0][fi].vertex_index[1]].position;
VC3 cross_e01_e02 = faces[fi].e01.GetCrossWith(faces[fi].e02);
if(cross_e01_e02.GetSquareLength() < 0.0001f)
{
CollisionFace &face = faces[fi];
face.sphere.radius = 0;
continue;
}
// Create plane
faces[fi].plane=PLANE(cross_e01_e02.GetNormalized(),faces[fi].vertex0);
// psd
CollisionFace *face = &faces[fi];
face->sphere.position = (face->vertex0 + face->vertex1 + face->vertex2) / 3;
face->sphere.radius = face->sphere.position.GetSquareRangeTo(face->vertex0);
float tmp = face->sphere.position.GetSquareRangeTo(face->vertex1);
if(tmp > face->sphere.radius)
face->sphere.radius = tmp;
tmp = face->sphere.position.GetSquareRangeTo(face->vertex2);
if(tmp > face->sphere.radius)
face->sphere.radius = tmp;
face->sphere.radius = sqrtf(face->sphere.radius);
if(face->sphere.position.x - face->sphere.radius < mmin.x)
mmin.x = face->sphere.position.x - face->sphere.radius;
if(face->sphere.position.z - face->sphere.radius < mmin.y)
mmin.y = face->sphere.position.z - face->sphere.radius;
if(face->sphere.position.x + face->sphere.radius > mmax.x)
mmax.x = face->sphere.position.x + face->sphere.radius;
if(face->sphere.position.z + face->sphere.radius > mmax.y)
mmax.y = face->sphere.position.z + face->sphere.radius;
}
tree = new StaticQuadtree<CollisionFace>(mmin, mmax);
//tree = new Quadtree<CollisionFace>(mmin, mmax);
for(int i = 0; i < face_amount; ++i)
{
CollisionFace &face = faces[i];
if(face.sphere.radius < 0.001f)
continue;
//tree->insert(&face, face.sphere.position, face.sphere.radius);
float mmin = min(face.vertex0.y, face.vertex1.y);
mmin = min(mmin, face.vertex2.y);
float mmax = max(face.vertex0.y, face.vertex1.y);
mmax = max(mmax, face.vertex2.y);
tree->insert(face, face.sphere.position, face.sphere.radius, mmin, mmax);
}
}
void FindPMV(MotionVector *MV_ptr, int x, int y,
int *pmv0, int *pmv1, int block, int newgob, int half_pel)
{
int p1,p2,p3;
int xin1,xin2,xin3;
int yin1,yin2,yin3;
int vec1,vec2,vec3;
int l8,o8,or8;
l8 = o8 = or8 = 0;
vec1 = (l8 ? 2 : 0) ; yin1 = y ; xin1 = x-1;
vec2 = (o8 ? 3 : 0) ; yin2 = y-1; xin2 = x;
vec3 = (or8? 3 : 0) ; yin3 = y-1; xin3 = x+1;
if (half_pel) {
p1 = (x > 0) ?
2*((*(MV_ptr + yin1*Global::mbc + xin1)).x) + (*(MV_ptr+ yin1*Global::mbc + xin1)).x_half : 0;
p2 = (y > 0) ?
2*((*(MV_ptr + yin2*Global::mbc + xin2)).x) + (*(MV_ptr + yin2*Global::mbc + xin2)).x_half : 2*NO_VEC;
if((y > 0) && (x < Global::mbc - 1))
p3 = 2*((*(MV_ptr+yin3*Global::mbc + xin3)).x) + ((*(MV_ptr + yin3*Global::mbc + xin3)).x_half);
else if(x == Global::mbc - 1)
p3 = 0;
else /* y == 0 && x != Global::mbc - 1 */
p3 = 2*NO_VEC;
}
else {
p1 = (x > 0) ?
(2*((*(MV_ptr + yin1*Global::mbc + xin1)).x)) : 0;
p2 = (y > 0) ?
(2*((*(MV_ptr + yin2*Global::mbc + xin2)).x)) : 2*NO_VEC;
if((y > 0) && (x < Global::mbc - 1))
p3 = 2*((*(MV_ptr + yin3*Global::mbc + xin3)).x);
else if(x == Global::mbc - 1)
p3 = 0;
else /* y == 0 && x != Global::mbc - 1 */
p3 = 2*NO_VEC;
}
if (newgob && (block == 0 || block == 1 || block == 2))
p2 = 2*NO_VEC;
if (p2 == 2*NO_VEC) { p2 = p3 = p1; }
*pmv0 = p1+p2+p3 - mmax(p1,mmax(p2,p3)) - mmin(p1,mmin(p2,p3));
if (half_pel) {
p1 = (x > 0) ?
(2*((*(MV_ptr + yin1*Global::mbc + xin1)).y)) + ((*(MV_ptr + yin1*Global::mbc + xin1)).y_half) : 0;
p2 = (y > 0) ?
2*((*(MV_ptr + yin2*Global::mbc + xin2)).y) + ((*(MV_ptr + yin2*Global::mbc + xin2)).y_half) : 2*NO_VEC;
if((y > 0) && (x < Global::mbc - 1))
p3 = 2*((*(MV_ptr + yin3*Global::mbc + xin3)).y) + ((*(MV_ptr + Global::mbc*yin3 + xin3)).y_half);
else if(x == Global::mbc - 1)
p3 = 0;
else /* y == 0 && x != Global::mbc - 1 */
p3 = 2*NO_VEC;
}
else {
p1 = (x > 0) ?
(2*((*(MV_ptr + yin1*Global::mbc + xin1)).y)) : 0;
p2 = (y > 0) ?
(2*((*(MV_ptr + yin2*Global::mbc + xin2)).y)) : 2*NO_VEC;
if((y > 0) && (x < Global::mbc - 1))
p3 = 2*((*(MV_ptr + yin3*Global::mbc + xin3)).y);
else if(x == Global::mbc - 1)
p3 = 0;
else /* y == 0 && x != Global::mbc - 1 */
p3 = 2*NO_VEC;
}
if (newgob && (block == 0 || block == 1 || block == 2))
p2 = 2*NO_VEC;
if (p2 == 2*NO_VEC) { p2 = p3 = p1; }
*pmv1 = p1+p2+p3 - mmax(p1,mmax(p2,p3)) - mmin(p1,mmin(p2,p3));
return;
}
void datatable2::load_csv(std::string filename, char separatorchar, char commentchar, std::string startswith, std::string endswith, int firstline){
//std::cout<<"datatable2::load_csv("<<filename<<")\n";
//std::cout.flush();
unsigned long lines=count_lines(filename);
//std::cout<<"datatable2::load_csv("<<filename<<"): lines="<<lines<<"\n";
//std::cout.flush();
unsigned long line=0, col=0;
// reserve enough lines for all lines in file (count lines in file)
resize(1,lines-(firstline-1));
clear(); // set accessible size to (0,0)
//std::cout<<"lines: "<<inttostr(lines)<<std::endl;
// now open the csv file
csv_in_separator=separatorchar;
csv_in_comment=commentchar;
title_line="";
csv_file=fopen(filename.c_str(), "rb");
if (csv_file==NULL) DATATABLE2_ERROR(DATATABLE2_ERROR_FILE_NUM, DATATABLE2_ERROR_FILE_MESSAGE, "datatable2.load_csv("+filename+")");
setvbuf(csv_file, NULL, _IOFBF ,1024*1024);
col=0;
line=0;
// now parse the file
double val;
bool readthiscol=false;
bool valueset=false;
std::string linest="";
//std::cout<<"startswith: '"<<startswith<<"'"<<std::endl;
if (firstline>1) {
int l=1;
while ((!feof(csv_file))&&(l<firstline)) {
/*char text[4096];
fgets(text, 4096 , csv_file);
//std::cout<<"ignore: '"<<text<<"'"<<std::endl;
linest=text;*/
char ch=0;
while ((!feof(csv_file)) && (ch!='\n') && (ch!='\r')) {
ch=fgetc(csv_file);
char ch1=fgetc(csv_file);
if (!((ch=='\n' && ch1=='\r')||(ch=='\r' && ch1=='\n'))) {
fseek(csv_file, -1, SEEK_CUR);
// if this isn't a \n\r or \r\n linebreak, we read a valid character and have to step back one character in the file
}
}
if ((ch=='\n') || (ch=='\r')) l++;
}
}
if (startswith.size()>0) {
while ((!feof(csv_file))&&(linest.find(startswith)==std::string::npos)) {
/*char text[4096];
fgets(text, 4096 , csv_file);
//std::cout<<"ignore: '"<<text<<"'"<<std::endl;
linest=text;*/
char ch=0;
linest="";
while ((!feof(csv_file)) && (ch!='\n') && (ch!='\r')) {
ch=fgetc(csv_file);
linest=linest+ch;
}
}
}
csv_endswith=endswith;
while(get_token()!=datatable2_EOF) {
/*switch (current_token) {
case datatable2_COMMENT:
//std::cout<<"datatable2_COMMENT\n";
break;
case datatable2_TITLECOMMENT: // the title comment line will be saved in title_line by get_token(), so it can be processed after parsing
//std::cout<<"datatable2_TITLECOMMENT\n";
break;
case datatable2_LINEBREAK:
//std::cout<<"datatable2_LINEBREAK\n";
break;
case datatable2_VALUE:
//std::cout<<"datatable2_VALUE\n";
break;
case datatable2_SEPARATOR:
//std::cout<<"datatable2_SEPARATOR\n";
break;
default: break;
}*/
switch (current_token) {
case datatable2_COMMENT:
case datatable2_TITLECOMMENT: // the title comment line will be saved in title_line by get_token(), so it can be processed after parsing
case datatable2_LINEBREAK:
if (readthiscol) line++;
col=0;
readthiscol=false;
valueset=false;
break;
case datatable2_VALUE:
val=0;
readthiscol=true;
// replace ',' by '.' to beeing able to read both decimal separators
//std::cout<<" '"<<current_value_string<<"' ";
if (current_value_string.size()>0)
for (size_t i=0; i<current_value_string.size(); i++) {
if (current_value_string[i]==',') current_value_string[i]='.';
}
val=atof(current_value_string.c_str());
//if (line<100) std::cout<<"(c="<<col<<", r="<<line<<") <= '"<<current_value_string<<"' "<<val<<"\n";
resize(mmax(column_count,col+1), mmax(line_count,line+1));
data[col][line].value= val;
data[col][line].empty= false;
valueset=true;
// for space/tab separated files there will be no datatable2_SEPARATOR token!!! so we directly enter the next column
if (isspace(csv_in_separator) || csv_in_separator=='0') {
resize(mmax(column_count,col+1), mmax(line_count,line+1));
valueset=false;
col++;
}
break;
case datatable2_SEPARATOR:
readthiscol=true;
if (!valueset){
data[col][line].value= 0;
data[col][line].empty= true;
}
col++;
//resize(mmax(column_count,col+1), mmax(line_count,line+1));
valueset=false;
break;
default: break;
}
}
fclose(csv_file);
clear_titles();
// now parse title_line:
if (title_line.size()>0) {
int title=0;
for (size_t i=0; i<title_line.size(); i++) {
if (title_line[i]==csv_in_separator) {
titles[title]=strstrip(titles[title]);
title++;
} else {
if (((titles[title].size()==0)&& (title_line[i]>32))||
((titles[title].size()>0)&&(title_line[i]!='\n')&&(title_line[i]!='\r')))
titles[title]+=title_line[i];
}
if (title>=(int)column_count) break;
}
}
//std::cout<<"'"<<title_line<<"'"<<std::endl;
}
if (Mode == MODE_INTRA) { /* Intra */
qcoeff[0] = mmax(1,mmin(254,coeff[0] >> 3)); /* was: /8 */
if(QP == 8) {
for(i = 1; i < 64; i++) {
level = (abs(coeff[i])) >> 4;
qcoeff[i] = mmin(127, mmax(-127,sign(coeff[i]) * level));
if(qcoeff[i])
CBP = CBP_Mask;
}
} else { /* QP != 8 */
for(i = 1; i < 64; i++) {
level = (abs(coeff[i])) / (2*QP);
qcoeff[i] = mmin(127,mmax(-127,sign(coeff[i]) * level));
if(qcoeff[i])
CBP = CBP_Mask;
}
} /* End QP == 8 */
}
else { /* non Intra */
if(QP == 8) {
for(i = 0; i < 64; i++) {
tempje = abs(coeff[i]) - 4;
if(tempje < 0) {
*(qcoeff++) = 0;
} else {
level = tempje >> 4; /* Note 2*QP == 2*8 = 2^4 == ">>4" */
if((*(qcoeff++) = mmin(127,mmax(-127,(sign(coeff[i]) > 0) ?
void simpleQPSolve(Matrix mH, Vector vG, Matrix mA, Vector vB, // in
Vector vP, Vector vLambda, int *info) // out
{
const double tolRelFeasibility=1e-6;
// int *info=NULL;
int dim=mA.nColumn(), nc=mA.nLine(), ncr, i,j,k, lastJ=-2, *ii;
MatrixTriangle M(dim);
Matrix mAR, mZ(dim,dim-1), mHZ(dim,dim-1), mZHZ(dim-1,dim-1);
Vector vTmp(mmax(nc,dim)), vYB(dim), vD(dim), vTmp2(dim), vTmp3(nc), vLast(dim),
vBR_QP, vLambdaScale(nc);
VectorChar vLB(nc);
double *lambda=vLambda, *br, *b=vB, violationMax, violationMax2,
*rlambda,ax,al,dviolation, **a=mA, **ar=mAR, mymin, mymax, maxb, *llambda,
**r,t, *scaleLambda=vLambdaScale;
char finished=0, feasible=0, *lb=vLB;
if (info) *info=0;
// remove lines which are null
k=0; vi_QP.setSize(nc); maxb=0.0;
for (i=0; i<nc; i++)
{
mymin=INF; mymax=-INF;
for (j=0; j<dim; j++)
{
mymin=mmin(mymin,a[i][j]);
mymax=mmax(mymax,a[i][j]);
if ((mymin!=mymax)||(mymin!=0.0)||(mymax!=0.0)) break;
}
if ((mymin!=mymax)||(mymin!=0.0)||(mymax!=0.0))
{
lambda[k]=lambda[i];
maxb=mmax(maxb,condorAbs(b[i]));
scaleLambda[k]=mA.euclidianNorm(i);
vi_QP[k]=i;
k++;
}
}
nc=k; vi_QP.setSize(nc); ii=vi_QP; maxb=(1.0+maxb)*tolRelFeasibility;
vLast.zero();
for (i=0; i<nc; i++) if (lambda[i]!=0.0) lb[i]=2; else lb[i]=1;
while (!finished)
{
finished=1;
mAR.setSize(dim,dim); mAR.zero(); ar=mAR;
vBR_QP.setSize(mmin(nc,dim)); br=vBR_QP;
ncr=0;
for (i=0; i<nc; i++)
if (lambda[i]!=0.0)
{
// mAR.setLines(ncr,mA,ii[i],1);
k=ii[i];
t=scaleLambda[ncr];
for (j=0; j<dim; j++) ar[ncr][j]=a[k][j]*t;
br[ncr]=b[ii[i]]*t;
ncr++;
}
mAR.setSize(ncr,dim);
vBR_QP.setSize(ncr);
vLastLambda_QP.copyFrom(vLambda); llambda=vLastLambda_QP;
if (ncr==0)
{
// compute step
vYB.copyFrom(vG);
vYB.multiply(-1.0);
if (mH.cholesky(M))
{
M.solveInPlace(vYB);
M.solveTransposInPlace(vYB);
} else
{
printf("warning: cholesky factorisation failed.\n");
if (info) *info=2;
}
vLambda.zero();
} else
{
Matrix mAR2=mAR.clone(), mQ2;
MatrixTriangle mR2;
mAR2.QR(mQ2,mR2);
mAR.QR(mQ_QP,mR_QP, viPermut_QP); // content of mAR is destroyed here !
bQRFailed_QP=0;
r=mR_QP;
for (i=0; i<ncr; i++)
if (r[i][i]==0.0)
{
// one constraint has been wrongly added.
bQRFailed_QP=1;
QPReconstructLambda(vLambda,vLambdaScale); vP.copyFrom(vLast); return;
}
for (i=0; i<ncr; i++)
if (viPermut_QP[i]!=i)
{
// printf("whoups.\n");
}
if (ncr<dim)
{
mQ_QP.getSubMatrix(mZ,0,ncr);
// Z^t H Z
mH.multiply(mHZ,mZ);
mZ.transposeAndMultiply(mZHZ,mHZ);
mQ_QP.setSize(dim,ncr);
}
// form Yb
vBR_QP.permutIn(vTmp,viPermut_QP);
mR_QP.solveInPlace(vTmp);
mQ_QP.multiply(vYB,vTmp);
if (ncr<dim)
{
// ( vG + H vYB )^t Z : result in vD
mH.multiply(vTmp,vYB);
vTmp+=vG;
vTmp.transposeAndMultiply(vD,mZ);
// calculate current delta (result in vD)
vD.multiply(-1.0);
if (mZHZ.cholesky(M))
{
M.solveInPlace(vD);
M.solveTransposInPlace(vD);
}
else
{
printf("warning: cholesky factorisation failed.\n");
if (info) *info=2;
};
// evaluate vX* (result in vYB):
mZ.multiply(vTmp, vD);
vYB+=vTmp;
}
// evaluate vG* (result in vTmp2)
mH.multiply(vTmp2,vYB);
vTmp2+=vG;
// evaluate lambda star (result in vTmp):
mQ2.transposeAndMultiply(vTmp,vTmp2);
mR2.solveTransposInPlace(vTmp);
// evaluate lambda star (result in vTmp):
mQ_QP.transposeAndMultiply(vTmp3,vTmp2);
mR_QP.solveTransposInPlace(vTmp3);
vTmp3.permutOut(vTmp,viPermut_QP);
rlambda=vTmp;
ncr=0;
for (i=0; i<nc; i++)
if (lambda[i]!=0.0)
{
lambda[i]=rlambda[ncr];
ncr++;
}
} // end of test on ncr==0
// find the most violated constraint j among non-active Linear constraints:
j=-1;
if (nc>0)
{
k=-1; violationMax=-INF; violationMax2=-INF;
for (i=0; i<nc; i++)
{
if (lambda[i]<=0.0) // test to see if this constraint is not active
{
ax=mA.scalarProduct(ii[i],vYB);
dviolation=b[ii[i]]-ax;
if (llambda[i]==0.0)
{
// the constraint was not active this round
// thus, it can enter the competition for the next
// active constraint
if (dviolation>maxb)
{
// the constraint should be activated
if (dviolation>violationMax2)
{ k=i; violationMax2=dviolation; }
al=mA.scalarProduct(ii[i],vLast)-ax;
if (al>0.0) // test to see if we are going closer
{
dviolation/=al;
if (dviolation>violationMax )
{ j=i; violationMax =dviolation; }
}
}
} else
{
lb[i]--;
if (feasible)
{
if (lb[i]==0)
{
vLambda.copyFrom(vLastLambda_QP);
if (lastJ>=0) lambda[lastJ]=0.0;
QPReconstructLambda(vLambda,vLambdaScale);
vP.copyFrom(vYB);
return;
}
} else
{
if (lb[i]==0)
{
if (info) *info=1;
QPReconstructLambda(vLambda,vLambdaScale);
vP.zero();
return;
}
}
finished=0; // this constraint was wrongly activated.
lambda[i]=0.0;
}
}
}
// !!! the order the tests is important here !!!
if ((j==-1)&&(!feasible))
{
feasible=1;
for (i=0; i<nc; i++) if (llambda[i]!=0.0) lb[i]=2; else lb[i]=1;
}
if (j==-1) { j=k; violationMax=violationMax2; } // change j to k after feasible is set
if (ncr==mmin(dim,nc)) {
if (feasible) { // feasible must have been checked before
QPReconstructLambda(vLambda,vLambdaScale); vP.copyFrom(vYB); return;
} else
{
if (info) *info=1;
QPReconstructLambda(vLambda,vLambdaScale); vP.zero(); return;
}
}
// activation of constraint only if ncr<mmin(dim,nc)
if (j>=0) { lambda[j]=1e-5; finished=0; } // we need to activate a new constraint
// else if (ncr==dim){
// QPReconstructLambda(vLambda); vP.copyFrom(vYB); return; }
}
// to prevent rounding error
if (j==lastJ) {
// if (0) {
QPReconstructLambda(vLambda,vLambdaScale); vP.copyFrom(vYB); return; }
lastJ=j;
vLast.copyFrom(vYB);
}
QPReconstructLambda(vLambda,vLambdaScale); vP.copyFrom(vYB); return;
}
{
return a>b ? b : a;
}
static inline ULONG mmax(ULONG a,ULONG b)
{
return a>b ? a : b;
}
VOID ObtainShineShadowPens (struct ColorMap *cmap, ULONG rgb, LONG &shine, LONG &shadow)
{
ULONG r = (rgb & 0xff0000) >> 16;
ULONG g = (rgb & 0x00ff00) >> 8;
ULONG b = rgb & 0x0000ff;
ULONG dark_r = mmax(64, r)-64;
ULONG dark_g = mmax(64, g)-64;
ULONG dark_b = mmax(64, b)-64;
ULONG bright_r = mmin(191, r)+64;
ULONG bright_g = mmin(191, g)+64;
ULONG bright_b = mmin(191, b)+64;
ULONG intencity = (r+g+b)/3;
if(intencity >= 215)
{
bright_r = mmin(255, dark_r+32);
bright_g = mmin(255, dark_g+32);
bright_b = mmin(255, dark_b+32);
dark_r = mmax(0, (LONG)dark_r-64);
void CONDOR( double rhoStart, double rhoEnd, int niter,
ObjectiveFunction *of, int nnode)
{
rhoStart=mmax(rhoStart,rhoEnd);
int dim=of->dim(), info, k, t, nerror;
double rho=rhoStart, delta=rhoStart, rhoNew,
lambda1, normD=rhoEnd+1.0, modelStep, reduction, r, valueOF, valueFk, bound, noise;
Vector d, tmp;
bool improvement, forceTRStep=true, evalNeeded;
initConstrainedStep(of);
// pre-create the MultInd indexes to prevent multi-thread problems:
cacheMultInd.get(dim,1); cacheMultInd.get(dim,2);
parallelInit(nnode, dim, of);
of->initData();
// points=getFirstPoints(&ValuesF, &nPtsTotal, rhoStart,of);
InterPolynomial poly(2, rho, Vector::emptyVector, of->data, of);
if (poly.NewtonBasis==NULL)
{
printf("cannot construct lagrange basis.\n");
exit(255);
}
//Base=poly.vBase;
k=poly.kbest;
valueFk=poly.valuesF[k];
fprintf(stderr,"init part 1 finished.\n");
/* InterPolynomial poly(dim,2,of);
for (;;)
{
// find index k of the best (lowest) value of the function
k=findK(ValuesF, nPtsTotal, of, points);
Base=points[k].clone();
// Base=of->xStart.clone();
valueFk=ValuesF[k];
// translation:
t=nPtsTotal; while (t--) points[t]-=Base;
// exchange index 0 and index k (to be sure best point is inside poly):
tmp=points[k];
points[k]=points[0];
points[0]=tmp;
ValuesF[k]=ValuesF[0];
ValuesF[0]=valueFk;
k=0;
poly=InterPolynomial(2, nPtsTotal, points, ValuesF);
if (poly.NewtonBasis!=NULL) break;
// the construction of the first polynomial has failed
// delete[] points;
free(ValuesF);
int kbest=findBest(of->data, of); // return 0 if startpoint is given
Vector BaseStart=of->data.getLine(kbest,dim);
double vBaseStart=((double**)of->data)[kbest][dim];
points=GenerateData(rho, BaseStart, vBaseStart, of, &ValuesF);
nPtsTotal=n;
}
*/
// update M:
fullUpdateOfM(rho,poly.vBase,of->data,poly);
fprintf(stderr,"init part 2 finished.\n");
fprintf(stderr,"init finished.\n");
// first of init all variables:
parallelImprove(&poly, &k, rho, &valueFk, poly.vBase);
// really start in parallel:
startParallelThread();
while (true)
{
// fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,QP_NF);
while (true)
{
// trust region step
while (true)
{
// poly.print();
parallelImprove(&poly, &k, rho, &valueFk, poly.vBase);
niter--;
if ((niter==0)
||(of->isConstrained&&checkForTermination(poly.NewtonPoints[k], poly.vBase, rhoEnd)))
{
poly.vBase+=poly.NewtonPoints[k];
fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,of->getNFE());
of->valueBest=valueFk;
of->xBest=poly.vBase;
// to do : compute H and Lambda
Vector vG(dim);
Matrix mH(dim,dim);
poly.gradientHessian(poly.NewtonPoints[k],vG,mH);
of->finalize(vG,mH,FullLambda.clone());
return;
}
// to debug:
fprintf(stderr,"Best Value Objective=%e (nfe=%i)\n", valueFk, of->getNFE());
d=ConstrainedL2NormMinimizer(poly,k,delta,&info,1000,&lambda1,poly.vBase,of);
// if (d.euclidianNorm()>delta)
// {
// printf("Warning d to long: (%e > %e)\n", d.euclidianNorm(), delta);
// }
normD=mmin(d.euclidianNorm(), delta);
d+=poly.NewtonPoints[k];
// next line is equivalent to reduction=valueFk-poly(d);
// BUT is more precise (no rounding error)
reduction=-poly.shiftedEval(d,valueFk);
//if (normD<0.5*rho) { evalNeeded=true; break; }
if ((normD<0.5*rho)&&(!forceTRStep)) { evalNeeded=true; break; }
// IF THE MODEL REDUCTION IS SMALL, THEN WE DO NOT SAMPLE FUNCTION
// AT THE NEW POINT. WE THEN WILL TRY TO IMPROVE THE MODEL.
noise=0.5*mmax(of->noiseAbsolute*(1+of->noiseRelative), abs(valueFk)*of->noiseRelative);
if ((reduction<noise)&&(!forceTRStep)) { evalNeeded=true; break; }
forceTRStep=false; evalNeeded=false;
if (quickHack) (*quickHack)(poly,k);
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp, &nerror);
of->saveValue(tmp,valueOF,nerror);
if (nerror)
{
// evaluation failed
delta*=0.5;
if (normD>=2*rho) continue;
break;
}
if (!of->isFeasible(tmp, &r))
{
fprintf(stderr, "violation: %e\n",r);
}
// update of delta:
r=(valueFk-valueOF)/reduction;
if (r<=0.1) delta=0.5*normD;
else if (r<0.7) delta=mmax(0.5*delta, normD);
else delta=mmax(rho+ normD, mmax(1.25*normD, delta));
// powell's heuristics:
if (delta<1.5*rho) delta=rho;
if (valueOF<valueFk)
{
t=poly.findAGoodPointToReplace(-1, rho, d,&modelStep);
k=t; valueFk=valueOF;
improvement=true;
// fprintf(stderr,"Value Objective=%e\n", valueOF);
} else
{
t=poly.findAGoodPointToReplace(k, rho, d,&modelStep);
improvement=false;
// fprintf(stderr,".");
};
if (t<0) { poly.updateM(d, valueOF); break; }
// If we are along constraints, it's more important to update
// the polynomial with points which increase its quality.
// Thus, we will skip this update to use only points coming
// from checkIfValidityIsInBound
if ((!of->isConstrained)||(improvement)||(reduction>0.0)||(normD<rho)) poly.replace(t, d, valueOF);
if (improvement) continue;
// if (modelStep>4*rho*rho) continue;
if (modelStep>2*rho) continue;
if (normD>=2*rho) continue;
break;
}
// model improvement step
forceTRStep=true;
// fprintf(stderr,"improvement step\n");
bound=0.0;
if (normD<0.5*rho)
{
bound=0.5*sqr(rho)*lambda1;
if (poly.nUpdateOfM<10) bound=0.0;
}
parallelImprove(&poly, &k, rho, &valueFk, poly.vBase);
// !! change d (if needed):
t=poly.checkIfValidityIsInBound(d, k, bound, rho );
if (t>=0)
{
if (quickHack) (*quickHack)(poly,k);
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp, &nerror);
if (nerror)
{
Vector GXk(dim);
Matrix H(dim,dim);
poly.NewtonBasis[t].gradientHessian(poly.NewtonPoints[k],GXk,H);
double rhot=rho,vmax;
while (nerror)
{
rhot*=.5;
d=LAGMAXModified(GXk,H,rhot,vmax);
d+=poly.NewtonPoints[k];
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp, &nerror);
of->saveValue(tmp,valueOF,nerror);
}
}
poly.replace(t, d, valueOF);
if ((valueOF<valueFk)&&
(of->isFeasible(tmp))) { k=t; valueFk=valueOF; };
continue;
}
// the model is perfect for this value of rho:
// OR
// we have crossed a non_linear constraint which prevent us to advance
if ((normD<=rho)||(reduction<0.0)) break;
}
// change rho because no improvement can now be made:
if (rho<=rhoEnd) break;
fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,of->getNFE());
if (rho<16*rhoEnd) rhoNew=rhoEnd;
else if (rho<250*rhoEnd) rhoNew=sqrt(rho*rhoEnd);
else rhoNew=0.1*rho;
delta=mmax(0.5*rho,rhoNew);
rho=rhoNew;
// update of the polynomial: translation of x[k].
// replace BASE by BASE+x[k]
poly.translate(poly.NewtonPoints[k]);
}
parallelFinish();
Vector vG(dim);
Matrix mH(dim,dim);
if (evalNeeded)
{
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp,&nerror);
of->saveValue(tmp,valueOF,nerror);
if ((nerror)||(valueOF<valueFk))
{
poly.vBase+=poly.NewtonPoints[k];
poly.gradientHessian(poly.NewtonPoints[k],vG,mH);
}
else
{
valueFk=valueOF; poly.vBase=tmp;
poly.gradientHessian(d,vG,mH);
}
} else
{
poly.vBase+=poly.NewtonPoints[k];
poly.gradientHessian(poly.NewtonPoints[k],vG,mH);
}
// delete[] points; :not necessary: done in destructor of poly which is called automatically:
fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,of->getNFE());
of->valueBest=valueFk;
of->xBest=poly.vBase;
of->finalize(vG,mH,FullLambda.clone());
}
