Hukommelse og Regnetid

Du bliver nok nødt til at beskrive hvad du har gjort (design af din klasse, data og metoder).

Jeg har kun erfaring fra Java (et gammelt studie projekt: http://www.mat.dtu.dk/people/T.Hoeholdt/DVD/index.html). Her måtte vi opgive at lægge regnereglerne for legemet ind i klassen. I stedet manipulerede vi data direkte og skrev dem tilbage i objektet.

Det er muligt at C++ er bedre på dette område, men i Java sker en del arbejde hver gang du opretter et objekt og når du kalder dets metoder.

objekternes størrelse er lig med summen af medlemmernes størrelse, så flere
felter bruger mere memory

virtuelle metoder fylder en pointer (typisk 4 byte) mens ikke virtuelle metoder
ikke fylder noget

det bliver altid langsomt hvis der ikke er plads i RAM til hele programmet
så det ryger på disk (page/swap fil).

rent beregnings mæssigt er operationer som sqrt, sin, cos, exp, pow etc.
meget meget dyrere end +-*/%

det er umuligt at gætte præcist havd der er galt med dit program uden at se noget
kodes

Point Poly::FaceNormal(int Face)
{
    Point Result;
    PointArray VertNormals;
    Ints FaceVerts = faceVerts(Face);
    for (int i=0; i<FaceVerts.Count(); i++)
    {
        Ints SharedEdges = Shared(vertEdges(FaceVerts[i]), faceEdges(Face));
        int Vert1 = connectedVert(FaceVerts[i], SharedEdges[0]);
        int Vert2 = connectedVert(FaceVerts[i], SharedEdges[1]);
        Point* Edge1 = new Point((Verts[Vert1]->X - Verts[FaceVerts[i]]->X),
                                (Verts[Vert1]->Y - Verts[FaceVerts[i]]->Y),
                                (Verts[Vert1]->Z - Verts[FaceVerts[i]]->Z));

        Point* Edge2 = new Point((Verts[Vert2]->X - Verts[FaceVerts[i]]->X),
                                (Verts[Vert2]->Y - Verts[FaceVerts[i]]->Y),
                                (Verts[Vert2]->Z - Verts[FaceVerts[i]]->Z));

        Point* Normal = new Point(((Edge1->Y*Edge2->Z)-(Edge1->Z*Edge2->Y)),
                                ((Edge1->Z*Edge2->X)-(Edge1->X*Edge2->Z)),
                                ((Edge1->X*Edge2->Y)-(Edge1->Y*Edge2->X)));

        double NLength = sqrt((Normal->X*Normal->X)+
                              (Normal->Y*Normal->Y)+
                              (Normal->Z*Normal->Z));

        VertNormals.Add(Normal->X/NLength,
                        Normal->Y/NLength,
                        Normal->Z/NLength);
        delete Edge1;
        delete Edge2;
        delete Normal;
    }



    for (int n=0; n<VertNormals.Count(); n++)
    {
        Result.X = VertNormals[n]->X;
        Result.Y = VertNormals[n]->Y;
        Result.Z = VertNormals[n]->Z;
    }

    Result.X = Result.X / VertNormals.Count();
    Result.Y = Result.Y / VertNormals.Count();
    Result.Z = Result.Z / VertNormals.Count();

    return Result;
}


Functionen laver en del beregninger og den skal helst gøre det her 40 gange i sek.
Tror ikke det bliver muligt så jeg bliver nok nød til at prøve at skære lidt ned på den.
Men hvis jeg ved hvad computeren specialt bruger meget kraft på.. Ville det også være nemmere i fremtiden at lave hurtigere functioner.

Det er svært at sige noget udfra den kode, fordi den kalder nogle andr emetoder.

Men umiddelbart ser det ikke specielt slemt ud.

Jeg må give arne_v ret. Dette ser ikke slemt ud. Generelt skal man altid se på den inderste løkke. Tid brugt i de andre løkker plejer at være ligegyldigt.

Her du overvejet at problemet måske bare er stort, og derfor bare tager lang tid.

Du kan overveje om det er nødvendigt at allokere (new'e) og frigive (delete) 3 gange for hver gennemløb.