Changeset 899


Ignore:
Timestamp:
11/30/19 02:13:25 (8 days ago)
Author:
Maciej Komosinski
Message:

Code formatting

Location:
cpp
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • cpp/common/nonstd_math.h

    r896 r899  
    6868
    6969#endif
    70 
  • cpp/frams/genetics/f4/f4_oper.cpp

    r896 r899  
    448448                int relid = neuid - id;
    449449                nn->l1 = relid;
    450                 //nn->l1 = (int)(4.0f * (rnd01 - 0.5f));
     450                //nn->l1 = (int)(4.0f * (rndDouble(1) - 0.5f));
    451451        }
    452452        // weight
    453453        nn->f1 = GenoOperators::mutateNeuProperty(nn->f1, NULL, -1);
    454         //nn->f1 = 10.0f * (rnd01 - 0.5f);
     454        //nn->f1 = 10.0f * (rndDouble(1) - 0.5f);
    455455}
    456456
     
    485485                        nn->l1 = neuid - id;
    486486                }
    487                 //nn->l1 += (int)(2.0f * (rnd01 - 0.5f));
     487                //nn->l1 += (int)(2.0f * (rndDouble(1) - 0.5f));
    488488                break;
    489489        case 2: // change weight
    490490                nn->f1 = GenoOperators::mutateNeuProperty(nn->f1, NULL, -1);
    491                 //nn->f1 += 1.0f * (rnd01 - 0.5f);
     491                //nn->f1 += 1.0f * (rndDouble(1) - 0.5f);
    492492                break;
    493493        }
     
    630630
    631631// decide number of nodes to mutate
    632 n = (int)( 0.5f + rnd01 * maxToMut );
     632n = (int)( 0.5f + rndDouble(1) * maxToMut );
    633633if (n<1) n=1;
    634634if (n>totNodes) n=totNodes;
  • cpp/frams/genetics/f9/f9_oper.cpp

    r896 r899  
    55#include "f9_oper.h"
    66#include "f9_conv.h"
    7 #include <common/nonstd.h> //rndUint, rnd01
     7#include <common/nonstd.h> //rndUint, rndDouble
    88
    99
  • cpp/frams/genetics/fF/fF_oper.cpp

    r896 r899  
    55#include "fF_oper.h"
    66#include "fF_genotype.h"
    7 #include <common/nonstd.h> //rndUint, rnd01
     7#include <common/nonstd.h> //rndUint, rndDouble
    88
    99
  • cpp/frams/genetics/fT/fTest_oper.cpp

    r896 r899  
    44
    55#include "fTest_oper.h"
    6 #include <common/nonstd.h> //randomN, rnd01
     6#include <common/nonstd.h> //randomN, rndDouble
    77
    88/**
  • cpp/frams/genetics/fn/fn_oper.cpp

    r896 r899  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2018  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2019  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
    55#include "fn_oper.h"
    66#include "fn_conv.h"
    7 #include <common/nonstd.h> //rndUint, rnd01
     7#include <common/nonstd.h> //rndUint, rndDouble
    88
    99
  • cpp/frams/genetics/genooperators.cpp

    r896 r899  
    7676}
    7777
    78 int GenoOperators::selectRandomProperty(Neuro* n)
     78int GenoOperators::selectRandomProperty(Neuro *n)
    7979{
    8080        int neuext = n->extraProperties().getPropCount(),
     
    129129                        if (strcmp(n, "fo") == 0 && strcmp(na, "Force") == 0) newval = CustomRnd(distrib_force); else
    130130                        {
    131                 double mn, mx, df;
    132                 getMinMaxDef(&p, i, mn, mx, df);
    133                 newval = mutateCreep(p.type(i)[0], oldval, mn, mx, true);
     131                                double mn, mx, df;
     132                                getMinMaxDef(&p, i, mn, mx, df);
     133                                newval = mutateCreep(p.type(i)[0], oldval, mn, mx, true);
    134134                        }
    135135        return true;
     
    195195                double v1 = p1[i];
    196196                double v2 = p2[i];
    197                 p1[i] = v1*proportion + v2*(1 - proportion);
    198                 p2[i] = v2*proportion + v1*(1 - proportion);
     197                p1[i] = v1 * proportion + v2 * (1 - proportion);
     198                p2[i] = v2 * proportion + v1 * (1 - proportion);
    199199        }
    200200}
     
    208208                double v1 = p1.getDouble(i1);
    209209                double v2 = p2.getDouble(i2);
    210                 p1.setDouble(i1, v1*proportion + v2*(1 - proportion));
    211                 p2.setDouble(i2, v2*proportion + v1*(1 - proportion));
     210                p1.setDouble(i1, v1 * proportion + v2 * (1 - proportion));
     211                p2.setDouble(i2, v2 * proportion + v1 * (1 - proportion));
    212212        }
    213213        else
    214214                if (type1 == 'd' && type2 == 'd')
    215215                {
    216                 int v1 = p1.getInt(i1);
    217                 int v2 = p2.getInt(i2);
    218                 setIntFromDoubleWithProbabilisticDithering(p1, i1, v1*proportion + v2*(1 - proportion));
    219                 setIntFromDoubleWithProbabilisticDithering(p2, i2, v2*proportion + v1*(1 - proportion));
     216                        int v1 = p1.getInt(i1);
     217                        int v2 = p2.getInt(i2);
     218                        setIntFromDoubleWithProbabilisticDithering(p1, i1, v1 * proportion + v2 * (1 - proportion));
     219                        setIntFromDoubleWithProbabilisticDithering(p2, i2, v2 * proportion + v1 * (1 - proportion));
    220220                }
    221221                else
     
    232232}
    233233
    234 NeuroClass* GenoOperators::getRandomNeuroClass()
    235 {
    236         vector<NeuroClass*> active;
     234NeuroClass *GenoOperators::getRandomNeuroClass()
     235{
     236        vector<NeuroClass *> active;
    237237        for (int i = 0; i < Neuro::getClassCount(); i++)
    238238                if (Neuro::getClass(i)->genactive)
     
    241241}
    242242
    243 NeuroClass* GenoOperators::getRandomNeuroClassWithOutput()
    244 {
    245         vector<NeuroClass*> active;
     243NeuroClass *GenoOperators::getRandomNeuroClassWithOutput()
     244{
     245        vector<NeuroClass *> active;
    246246        for (int i = 0; i < Neuro::getClassCount(); i++)
    247247                if (Neuro::getClass(i)->genactive && Neuro::getClass(i)->getPreferredOutput() != 0)
     
    250250}
    251251
    252 NeuroClass* GenoOperators::getRandomNeuroClassWithInput()
    253 {
    254         vector<NeuroClass*> active;
     252NeuroClass *GenoOperators::getRandomNeuroClassWithInput()
     253{
     254        vector<NeuroClass *> active;
    255255        for (int i = 0; i < Neuro::getClassCount(); i++)
    256256                if (Neuro::getClass(i)->genactive && Neuro::getClass(i)->getPreferredInputs() != 0)
     
    259259}
    260260
    261 NeuroClass* GenoOperators::getRandomNeuroClassWithOutputAndNoInputs()
    262 {
    263         vector<NeuroClass*> active;
     261NeuroClass *GenoOperators::getRandomNeuroClassWithOutputAndNoInputs()
     262{
     263        vector<NeuroClass *> active;
    264264        for (int i = 0; i < Neuro::getClassCount(); i++)
    265265                if (Neuro::getClass(i)->genactive && Neuro::getClass(i)->getPreferredOutput() != 0 && Neuro::getClass(i)->getPreferredInputs() == 0)
     
    268268}
    269269
    270 int GenoOperators::getRandomNeuroClassWithOutput(const vector<NeuroClass*>& NClist)
     270int GenoOperators::getRandomNeuroClassWithOutput(const vector<NeuroClass *> &NClist)
    271271{
    272272        vector<int> allowed;
     
    277277}
    278278
    279 int GenoOperators::getRandomNeuroClassWithInput(const vector<NeuroClass*>& NClist)
     279int GenoOperators::getRandomNeuroClassWithInput(const vector<NeuroClass *> &NClist)
    280280{
    281281        vector<int> allowed;
     
    301301}
    302302
    303 NeuroClass* GenoOperators::parseNeuroClass(char*& s)
     303NeuroClass *GenoOperators::parseNeuroClass(char *&s)
    304304{
    305305        int maxlen = (int)strlen(s);
    306306        int NClen = 0;
    307307        NeuroClass *NC = NULL;
    308         for (int i = 0; i<Neuro::getClassCount(); i++)
     308        for (int i = 0; i < Neuro::getClassCount(); i++)
    309309        {
    310310                const char *ncname = Neuro::getClass(i)->name.c_str();
    311311                int ncnamelen = (int)strlen(ncname);
    312                 if (maxlen >= ncnamelen && ncnamelen>NClen && (strncmp(s, ncname, ncnamelen) == 0))
     312                if (maxlen >= ncnamelen && ncnamelen > NClen && (strncmp(s, ncname, ncnamelen) == 0))
    313313                {
    314314                        NC = Neuro::getClass(i);
     
    320320}
    321321
    322 Neuro* GenoOperators::findNeuro(const Model *m, const NeuroClass *nc)
     322Neuro *GenoOperators::findNeuro(const Model *m, const NeuroClass *nc)
    323323{
    324324        if (!m) return NULL;
     
    328328}
    329329
    330 int GenoOperators::neuroClassProp(char*& s, NeuroClass *nc, bool also_v1_N_props)
     330int GenoOperators::neuroClassProp(char *&s, NeuroClass *nc, bool also_v1_N_props)
    331331{
    332332        int len = (int)strlen(s);
     
    335335        {
    336336                Param p = nc->getProperties();
    337                 for (int i = 0; i<p.getPropCount(); i++)
     337                for (int i = 0; i < p.getPropCount(); i++)
    338338                {
    339339                        const char *n = p.id(i);
    340340                        int l = (int)strlen(n);
    341                         if (len >= l && l>Len && (strncmp(s, n, l) == 0)) { I = 100 + i; Len = l; }
     341                        if (len >= l && l > Len && (strncmp(s, n, l) == 0)) { I = 100 + i; Len = l; }
    342342                        if (also_v1_N_props) //recognize old properties symbols /=!
    343343                        {
     
    352352        Neuro n;
    353353        Param p = n.extraProperties();
    354         for (int i = 0; i<p.getPropCount(); i++)
     354        for (int i = 0; i < p.getPropCount(); i++)
    355355        {
    356356                const char *n = p.id(i);
    357357                int l = (int)strlen(n);
    358                 if (len >= l && l>Len && (strncmp(s, n, l) == 0)) { I = i; Len = l; }
     358                if (len >= l && l > Len && (strncmp(s, n, l) == 0)) { I = i; Len = l; }
    359359        }
    360360        s += Len;
     
    389389}
    390390
    391 char* GenoOperators::strchrn0(const char *str, char ch)
    392 {
    393         return ch == 0 ? NULL : strchr((char*)str, ch);
     391char *GenoOperators::strchrn0(const char *str, char ch)
     392{
     393        return ch == 0 ? NULL : strchr((char *)str, ch);
    394394}
    395395
     
    398398        return isupper(firstchar) || firstchar == '|' || firstchar == '@' || firstchar == '*';
    399399}
    400 
  • cpp/frams/genetics/genooperators.h

    r801 r899  
    198198        static NeuroClass* getRandomNeuroClassWithInput(); ///<returns random neuroclass with input or NULL when no active classes.
    199199        static NeuroClass* getRandomNeuroClassWithOutputAndNoInputs(); ///<returns random sensor or NULL when no active classes.
    200         static NeuroClass* getRandomSensorProb(float prob); ///<returns random sensor (only-output neuron class) with presented probability or NULL. \e prob probability of picking neuron class.
    201200        static int getRandomNeuroClassWithOutput(const vector<NeuroClass*>& NClist); ///<returns index of random NeuroClass from the NClist or -1 (no neurons on the list that provide output) \e NClist list of available neuron classes
    202201        static int getRandomNeuroClassWithInput(const vector<NeuroClass*>& NClist); ///<returns index of random NeuroClass from the NClist or -1 (no neurons on the list that want input(s)) \e NClist list of available neuron classes
  • cpp/frams/model/modelparts.cpp

    r844 r899  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2017  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2019  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    7474}
    7575
    76 void PartBase::setInfo(const SString& name, const SString& value)
     76void PartBase::setInfo(const SString &name, const SString &value)
    7777{
    7878        strSetField(info, name, value);
    7979}
    8080
    81 void PartBase::setInfo(const SString& name, int value)
     81void PartBase::setInfo(const SString &name, int value)
    8282{
    8383        setInfo(name, SString::valueOf(value));
    8484}
    8585
    86 void PartBase::setInfo(const SString& name, double value)
     86void PartBase::setInfo(const SString &name, double value)
    8787{
    8888        setInfo(name, SString::valueOf(value));
    8989}
    9090
    91 SString PartBase::getInfo(const SString& name)
     91SString PartBase::getInfo(const SString &name)
    9292{
    9393        return strGetField(info, name);
     
    134134}
    135135
    136 void NeuroClass::setGenActive(const char* genactive_classes[])
    137 {
    138         for (const char** n = genactive_classes; *n; n++)
    139         {
    140                 NeuroClass* cls = Neuro::getClass(*n);
     136void NeuroClass::setGenActive(const char *genactive_classes[])
     137{
     138        for (const char **n = genactive_classes; *n; n++)
     139        {
     140                NeuroClass *cls = Neuro::getClass(*n);
    141141                if (cls) cls->genactive = 1;
    142142        }
     
    223223}
    224224
    225 SString** Neuro::inputInfo(int i)
     225SString **Neuro::inputInfo(int i)
    226226{
    227227        if (i >= getInputCount()) return 0;
     
    229229}
    230230
    231 void Neuro::setInputInfo(int i, const SString& name, const SString &value)
     231void Neuro::setInputInfo(int i, const SString &name, const SString &value)
    232232{
    233233        SString **s = inputInfo(i);
     
    237237}
    238238
    239 void Neuro::setInputInfo(int i, const SString& name, int value)
     239void Neuro::setInputInfo(int i, const SString &name, int value)
    240240{
    241241        setInputInfo(i, name, SString::valueOf(value));
    242242}
    243243
    244 void Neuro::setInputInfo(int i, const SString& name, double value)
     244void Neuro::setInputInfo(int i, const SString &name, double value)
    245245{
    246246        setInputInfo(i, name, SString::valueOf(value));
     
    255255}
    256256
    257 SString Neuro::getInputInfo(int i, const SString& name)
     257SString Neuro::getInputInfo(int i, const SString &name)
    258258{
    259259        SString **s = inputInfo(i);
     
    263263}
    264264
    265 void Neuro::operator=(const Neuro& src)
     265void Neuro::operator=(const Neuro &src)
    266266{
    267267        refno = src.refno;
     
    294294}
    295295
    296 NeuroClass* Neuro::getClass(int classindex)
     296NeuroClass *Neuro::getClass(int classindex)
    297297{
    298298        return NeuroLibrary::staticlibrary.getClass(classindex);
    299299}
    300300
    301 NeuroClass* Neuro::getClass(const SString& classname)
     301NeuroClass *Neuro::getClass(const SString &classname)
    302302{
    303303        return NeuroLibrary::staticlibrary.findClass(classname);
    304304}
    305305
    306 int Neuro::getClassIndex(const NeuroClass*nc)
    307 {
    308         return NeuroLibrary::staticlibrary.classes.find((void*)nc);
    309 }
    310 
    311 NeuroClass* Neuro::getClass()
     306int Neuro::getClassIndex(const NeuroClass *nc)
     307{
     308        return NeuroLibrary::staticlibrary.classes.find((void *)nc);
     309}
     310
     311NeuroClass *Neuro::getClass()
    312312{
    313313        checkClass();
     
    315315}
    316316
    317 void Neuro::setClass(NeuroClass* cl)
     317void Neuro::setClass(NeuroClass *cl)
    318318{
    319319        myclass = cl;
     
    328328}
    329329
    330 void Neuro::setDetails(const SString& details)
     330void Neuro::setDetails(const SString &details)
    331331{
    332332        int colon = details.indexOf(':');
     
    362362}
    363363
    364 void Neuro::setClassName(const SString& clazz)
     364void Neuro::setClassName(const SString &clazz)
    365365{
    366366        myclassname = clazz;
     
    368368}
    369369
    370 int Neuro::addInput(Neuro* child, double weight, const SString *info)
     370int Neuro::addInput(Neuro *child, double weight, const SString *info)
    371371{
    372372        inputs += NInput(child, weight, (info && (info->len())) ? new SString(*info) : 0);
     
    376376}
    377377
    378 int Neuro::findInput(Neuro* child) const
     378int Neuro::findInput(Neuro *child) const
    379379{
    380380        for (int i = 0; i < inputs.size(); i++)
     
    383383}
    384384
    385 Neuro* Neuro::getInput(int i, double &weight) const
     385Neuro *Neuro::getInput(int i, double &weight) const
    386386{
    387387        if (i >= getInputCount()) return 0;
     
    401401}
    402402
    403 void Neuro::setInput(int i, Neuro* n)
     403void Neuro::setInput(int i, Neuro *n)
    404404{
    405405        NInput &inp = inputs(i);
     
    407407}
    408408
    409 void Neuro::setInput(int i, Neuro* n, double w)
     409void Neuro::setInput(int i, Neuro *n, double w)
    410410{
    411411        NInput &inp = inputs(i);
     
    424424}
    425425
    426 int Neuro::removeInput(Neuro* child)
     426int Neuro::removeInput(Neuro *child)
    427427{
    428428        int i = findInput(child);
     
    463463}
    464464
    465 int Neuro::findInputs(SList& result, const char* classname, const Part* part, const Joint* joint) const
     465int Neuro::findInputs(SList &result, const char *classname, const Part *part, const Joint *joint) const
    466466{
    467467        Neuro *nu;
     
    476476                if (classname)
    477477                        if (nu->getClassName() != cn) continue;
    478                 result += (void*)nu;
     478                result += (void *)nu;
    479479        }
    480480        return result.size() - n0;
    481481}
    482482
    483 int Neuro::findOutputs(SList& result, const char* classname, const Part* part, const Joint* joint) const
     483int Neuro::findOutputs(SList &result, const char *classname, const Part *part, const Joint *joint) const
    484484{ // not very efficient...
    485485        Neuro *nu, *inp;
     
    498498                        if (inp == this)
    499499                        {
    500                         result += (void*)nu;
    501                         break;
     500                                result += (void *)nu;
     501                                break;
    502502                        }
    503503        }
     
    576576}
    577577
    578 void Part::operator=(const Part& src)
     578void Part::operator=(const Part &src)
    579579{
    580580        p = src.p; o = src.o;
     
    612612        Pt3D x = p2 - p1;
    613613        Pt3D dir(x.y, x.z, x.x);
    614         p = p1 + x*0.5;
     614        p = p1 + x * 0.5;
    615615        rot.getAngles(x, dir);
    616616}
    617617
    618 Param& Part::getStaticParam()
     618Param &Part::getStaticParam()
    619619{
    620620        static Param p(f0_part_paramtab, 0, "Part");
     
    637637}
    638638
    639 void Joint::operator=(const Joint& src)
     639void Joint::operator=(const Joint &src)
    640640{
    641641        rot = src.rot;
     
    652652}
    653653
    654 void Joint::attachToParts(Part* p1, Part* p2)
     654void Joint::attachToParts(Part *p1, Part *p2)
    655655{
    656656        part1 = p1;
     
    695695}
    696696
    697 Param& Joint::getStaticParam()
     697Param &Joint::getStaticParam()
    698698{
    699699        static Param p(f0_joint_paramtab, 0, "Joint");
     
    760760};
    761761
    762 Param& Neuro::getStaticParam()
     762Param &Neuro::getStaticParam()
    763763{
    764764        static Param p(f0_neuro_paramtab, 0, "NeuroDef");
  • cpp/frams/model/modelparts.h

    r844 r899  
    2424class MultiRange;
    2525
    26 typedef UserTags<Model, void*, 5> ModelUserTags;
     26typedef UserTags<Model, void *, 5> ModelUserTags;
    2727
    2828/** Common base for model elements. */
     
    3131public:
    3232        SString vis_style;
    33         PartBase(const SString& s) :vis_style(s), mapped(0) {}
     33        PartBase(const SString &s) :vis_style(s), mapped(0) {}
    3434        ~PartBase();
    35         static SString getDefaultStyle(){ return SString("none"); }
     35        static SString getDefaultStyle() { return SString("none"); }
    3636        MultiRange *mapped;
    3737        enum PartBaseFlags { Selected = 1 };
     
    4848
    4949        void clearMapping();
    50         MultiRange* getMapping() { return mapped; }
     50        MultiRange *getMapping() { return mapped; }
    5151        void setMapping(const IRange &mr);
    5252        void addMapping(const IRange &mr);
     
    5454        void addMapping(const MultiRange &mr);
    5555
    56         void setInfo(const SString& name, const SString& value);
    57         void setInfo(const SString& name, int value);
    58         void setInfo(const SString& name, double value);
    59         SString getInfo(const SString& name);
     56        void setInfo(const SString &name, const SString &value);
     57        void setInfo(const SString &name, int value);
     58        void setInfo(const SString &name, double value);
     59        SString getInfo(const SString &name);
    6060};
    6161
     
    9494
    9595        Part(enum Shape s = SHAPE_BALL_AND_STICK);
    96         Part(const Part& src) :PartBase(getDefaultStyle()) { operator=(src); }
    97         void operator=(const Part& src);
     96        Part(const Part &src) :PartBase(getDefaultStyle()) { operator=(src); }
     97        void operator=(const Part &src);
    9898
    9999        void setPositionAndRotationFromAxis(const Pt3D &p1, const Pt3D &p2);
     
    101101        void setRot(const Pt3D &r);///< set part.rot (rotation angles) and calculate part.o
    102102
    103         static Param& getStaticParam();
     103        static Param &getStaticParam();
    104104};
    105105
     
    128128
    129129        Joint();
    130         Joint(const Joint& src) :PartBase(getDefaultStyle()) { operator=(src); }
    131         void operator=(const Joint& src);
     130        Joint(const Joint &src) :PartBase(getDefaultStyle()) { operator=(src); }
     131        void operator=(const Joint &src);
    132132
    133133        /** connect two parts with this joint.
     
    135135                @see isDelta()
    136136                */
    137         void attachToParts(Part* p1, Part* p2);
     137        void attachToParts(Part *p1, Part *p2);
    138138        /// @see attachToParts(Part*,Part*)
    139139        void attachToParts(int p1, int p2);
     
    168168        Pt3D vcolor;
    169169
    170         static Param& getStaticParam();
     170        static Param &getStaticParam();
    171171};
    172172
    173173#define JOINT_DELTA_MARKER 99999.0
    174174
    175 ////////////////// NN /////////////////
     175
     176
     177////////////////// Neural Network /////////////////
    176178
    177179class NeuroClass;
    178180
    179 typedef UserTags<NeuroClass, void*, 5> NeuroClassUserTags;
     181typedef UserTags<NeuroClass, void *, 5> NeuroClassUserTags;
    180182
    181183/** Information about neuron class.
     
    184186{
    185187        bool ownedvectordata;
    186         void operator=(const NeuroClass& nosuchthich){}
     188        void operator=(const NeuroClass &nosuchthich) {}
    187189public:
    188190        SString name, longname, description;
     
    207209        /** class name for use in Neuro::setClassName(), Neuro::setDetails() (former 'moredata' field),
    208210                eg. "N","-",G" */
    209         const SString& getName() { return name; }
     211        const SString &getName() { return name; }
    210212        /** human friendly name, eg. "Neuron","Link","Gyroscope"  */
    211         const SString& getLongName() { return longname; }
     213        const SString &getLongName() { return longname; }
    212214        /** long description */
    213         const SString& getDescription() { return description; }
    214         ParamEntry* getParamTab() { return props; }
     215        const SString &getDescription() { return description; }
     216        ParamEntry *getParamTab() { return props; }
    215217
    216218        /** NeuroClass specific properties, recognized by all neurons of this class */
     
    240242                }
    241243                */
    242         int* getSymbolGlyph()
     244        int *getSymbolGlyph()
    243245        {
    244246                return vectordata;
     
    246248        void setSymbolGlyph(int *data, bool owned = 1)
    247249        {
    248                 if (vectordata&&ownedvectordata) delete[]vectordata;
     250                if (vectordata && ownedvectordata) delete[]vectordata;
    249251                vectordata = data; ownedvectordata = owned;
    250252        }
     
    282284
    283285        static void resetActive(); ///< set default values of active and genactive for all classes
    284         static void setGenActive(const char* classes[]); ///< set genactive for specified classes
    285 };
    286 
    287 class Neuro;
    288 
    289 /** Single processing unit in Framsticks NN.  */
     286        static void setGenActive(const char *classes[]); ///< set genactive for specified classes
     287};
     288
     289
     290
     291
     292
     293
     294/** Single processing unit in Framsticks neural network.  */
    290295class Neuro : public PartBase
    291296{
     
    305310        /** set myclass and make knownclass=true */
    306311        void checkClass();
    307         SString** inputInfo(int i);
     312        SString **inputInfo(int i);
    308313        void defassign();
    309314
     
    313318        Param extraProperties();
    314319
    315         void setInputInfo(int i, const SString& name, const SString &value);
    316         void setInputInfo(int i, const SString& name, int value);
    317         void setInputInfo(int i, const SString& name, double value);
     320        void setInputInfo(int i, const SString &name, const SString &value);
     321        void setInputInfo(int i, const SString &name, int value);
     322        void setInputInfo(int i, const SString &name, double value);
    318323        SString getInputInfo(int i);
    319         SString getInputInfo(int i, const SString& name);
    320 
    321         NeuroClass* getClass();
    322         void setClass(NeuroClass*);
     324        SString getInputInfo(int i, const SString &name);
     325
     326        NeuroClass *getClass();
     327        void setClass(NeuroClass *);
    323328
    324329        SString getClassParams() { return myclassparams; }
    325         void setClassParams(const SString& cp) { myclassparams = cp; }
     330        void setClassParams(const SString &cp) { myclassparams = cp; }
    326331
    327332        SString getClassName();
    328         void setClassName(const SString& clazz);
     333        void setClassName(const SString &clazz);
    329334
    330335        /** return neuro unit details encoded as <CLASS> ":" <PROPERTIES>
     
    351356                @see getDetails()
    352357                */
    353         void setDetails(const SString&);
     358        void setDetails(const SString &);
    354359
    355360#define STATRICKCLASS Neuro
     
    377382        Neuro();
    378383        Neuro(double _state, double _inertia, double _force, double _sigmo);
    379         Neuro(const Neuro& src) :PartBase(getDefaultStyle()) { operator=(src); }
     384        Neuro(const Neuro &src) :PartBase(getDefaultStyle()) { operator=(src); }
    380385
    381386        ~Neuro();
    382387
    383         void operator=(const Neuro& src);
     388        void operator=(const Neuro &src);
    384389
    385390        /** Attach this Neuro to the specified Part or detach it from the body if p==NULL.
     
    387392                @see getPart()
    388393                */
    389         void attachToPart(Part* p) { part = p; joint = 0; }
     394        void attachToPart(Part *p) { part = p; joint = 0; }
    390395
    391396        /** Attach this Neuro to the specified Joint or detach it from the body if p==NULL.
     
    393398                @see getJoint()
    394399                */
    395         void attachToJoint(Joint* j) { joint = j; part = 0; }
     400        void attachToJoint(Joint *j) { joint = j; part = 0; }
    396401
    397402        void attachToPart(int i);
     
    422427
    423428        /** @return the Neuro connected as i-th input */
    424         Neuro* getInput(int i) const { return (i >= inputs.size()) ? 0 : inputs(i).n; }
     429        Neuro *getInput(int i) const { return (i >= inputs.size()) ? 0 : inputs(i).n; }
    425430        /** @return the Neuro connected as i-th input.
    426431                @param weight
    427432                */
    428         Neuro* getInput(int i, double &weight) const;
     433        Neuro *getInput(int i, double &weight) const;
    429434        /** @return connectin weight for i-th input */
    430435        double getInputWeight(int i) const;
     
    432437        void setInputWeight(int i, double weight);
    433438        /** connect i-th input with another neuron */
    434         void setInput(int i, Neuro*n);
     439        void setInput(int i, Neuro *n);
    435440        /** connect i-th input with another neuron */
    436         void setInput(int i, Neuro*n, double weight);
     441        void setInput(int i, Neuro *n, double weight);
    437442        /** add new input. @return its reference number */
    438         int addInput(Neuro* child, double weight = 1.0, const SString* info = 0);
     443        int addInput(Neuro *child, double weight = 1.0, const SString *info = 0);
    439444        /** @return reference number [0..InputCount-1] of the input
    440445           or -1 if 'child' is not connected with this Neuro.*/
    441         int findInput(Neuro* child) const;
     446        int findInput(Neuro *child) const;
    442447        void removeInput(paInt refno);
    443448        /**    @return reference number of the child connection, like findInput() */
    444         int removeInput(Neuro* child);
    445 
    446         int findInputs(SList& result, const char* classname = 0, const Part* part = 0, const Joint* joint = 0) const;
    447         int findOutputs(SList& result, const char* classname = 0, const Part* part = 0, const Joint* joint = 0) const;
     449        int removeInput(Neuro *child);
     450
     451        int findInputs(SList &result, const char *classname = 0, const Part *part = 0, const Joint *joint = 0) const;
     452        int findOutputs(SList &result, const char *classname = 0, const Part *part = 0, const Joint *joint = 0) const;
    448453
    449454        /* class database retrieval */
     
    453458                */
    454459        static SString getClassName(int classindex);
    455         static NeuroClass* getClass(int classindex);
    456         static NeuroClass* getClass(const SString& classname);
    457         static int getClassIndex(const NeuroClass*nc);
     460        static NeuroClass *getClass(int classindex);
     461        static NeuroClass *getClass(const SString &classname);
     462        static int getClassIndex(const NeuroClass *nc);
    458463
    459464        // not really private, but you should not access those directly
     
    468473        Orient o;       ///< rotation matrix calculated from "rot"
    469474        static ParamEntry emptyParamTab[];
    470         static Param& getStaticParam();
     475        static Param &getStaticParam();
    471476};
    472477
Note: See TracChangeset for help on using the changeset viewer.