Changeset 1158 for cpp/frams


Ignore:
Timestamp:
10/01/21 23:40:49 (3 years ago)
Author:
Maciej Komosinski
Message:

Cosmetic/minor improvements

Location:
cpp/frams
Files:
12 edited
1 moved

Legend:

Unmodified
Added
Removed
  • cpp/frams/Makefile-SDK

    r1035 r1158  
    1111CXXWARNINGS=-Wall -Wno-parentheses -Wno-overloaded-virtual -Wno-format -Werror=return-type
    1212
    13 SDK_BUILD_CONFIG= -include frams/config/sdk_build_config.h
     13SDK_BUILD_CONFIG= -include frams/config/sdk-build-config.h
    1414CXXFLAGS= -I$(CURDIR) -std=gnu++17 $(SDK_BUILD_CONFIG) $(CXXWARNINGS) -g
    1515
  • cpp/frams/frams-objects.h

    r1123 r1158  
    2525EXPORTED char* extPropId(void *v, int i);
    2626EXPORTED char* extPropType(void *v, int i);
     27EXPORTED char* extPropName(void *v, int i);
     28EXPORTED int extPropFlags(void *v, int i);
     29EXPORTED int extPropGroup(void *v, int i);
     30EXPORTED char* extPropHelp(void *v, int i);
    2731EXPORTED int extPropFind(void *v, char* id);
    2832EXPORTED void* extPropGet(void *v, int i);
    2933EXPORTED int extPropSet(void *v, int i, void* e);
    3034EXPORTED void* extPropCall(void *v, int i, int argc, void* argv);
     35EXPORTED int extGroupCount(void *v);
     36EXPORTED char* extGroupName(void *v, int i);
     37EXPORTED int extGroupMember(void *v, int g, int i);
     38EXPORTED int extMemberCount(void *v, int g);
    3139EXPORTED void* rootObject();
    3240
  • cpp/frams/genetics/fS/fS_general.h

    r1032 r1158  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 2019-2020  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 2019-2021  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    1111#include <unordered_map>
    1212#include <exception>
     13#include <algorithm>
    1314#include "frams/model/model.h"
    1415#include "frams/util/multirange.h"
  • cpp/frams/model/geometry/modelgeoclass.cpp

    r1115 r1158  
    1818        "To set geom_density for individual ModelGeometry objects:\n"
    1919        "var mg=ModelGeometry.forModel(GenePools[0][0].getModel()); mg.geom_density=2; GenePools[0][0].data->area=mg.area();\n" },
    20         { "geom_density", 0, 0, "Density", "f 0.01 100.0 1.0", FIELD(density), "The number of samples (per unit length in one dimension) that affects the precision of estimation of geometrical properties." }, //note: we used 'geom_density' instead of 'density' to make the name more unique - because sim_params merges all configuration fields in a single namespace.
     20        { "geom_density", 0, 0, "Density", "f 0.01 100.0 3.0", FIELD(density), "The number of samples (per unit length in one dimension) that affects the precision of estimation of geometrical properties." }, //Note #1: we used 'geom_density' instead of 'density' to make the name more unique - because sim_params merges all configuration fields in a single namespace. Note #2: "density" needs better, more interpretable and more reliable parametrization for surface sampling...
    2121        { "forModel", 0, PARAM_USERHIDDEN, "", "p oModelGeometry(oModel)", PROCEDURE(p_formodel), "The returned ModelGeometry object can be used to calculate geometric properties (volume, area, sizes) of the associated model. The density is copied from the current global ModelGeometry.geom_density on object creation." },
    2222        { "volume", 0, PARAM_NOSTATIC | PARAM_USERHIDDEN, "volume", "p f()", PROCEDURE(p_volume), },
  • cpp/frams/model/modelobj.cpp

    r999 r1158  
    2121        { "numconnections", 0, PARAM_DONTSAVE | PARAM_NOSTATIC | PARAM_READONLY, "Number of neuron connections", "d", GETONLY(numconnections), },
    2222
    23         { "getPart", 0, PARAM_USERHIDDEN | PARAM_NOSTATIC, "getPart (static model information)", "p oPart(d index)", PROCEDURE(p_getpart), },
    24         { "getJoint", 0, PARAM_USERHIDDEN | PARAM_NOSTATIC, "getJoint (static model information)", "p oJoint(d index)", PROCEDURE(p_getjoint), },
    25         { "getNeuroDef", 0, PARAM_USERHIDDEN | PARAM_NOSTATIC, "getNeuroDef", "p oNeuroDef(d index)", PROCEDURE(p_getneuro), },
     23        { "getPart", 0, PARAM_READONLY | PARAM_USERHIDDEN | PARAM_NOSTATIC, "getPart (static model information)", "p oPart(d index)", PROCEDURE(p_getpart), },
     24        { "getJoint", 0, PARAM_READONLY | PARAM_USERHIDDEN | PARAM_NOSTATIC, "getJoint (static model information)", "p oJoint(d index)", PROCEDURE(p_getjoint), },
     25        { "getNeuroDef", 0, PARAM_READONLY | PARAM_USERHIDDEN | PARAM_NOSTATIC, "getNeuroDef", "p oNeuroDef(d index)", PROCEDURE(p_getneuro), },
    2626
    2727        { "size_x", 0, PARAM_READONLY | PARAM_NOSTATIC | PARAM_DEPRECATED, "Bounding box x size", "f", FIELD(size.x), "(size_x,size_y,size_z) are dimensions of the axis-aligned bounding box of the creature, including imaginary Part sizes (Part.s, usually 1.0). A creature consisting of a single default part has the size of (2.0,2.0,2.0) - twice the Part.s value (like a sphere diameter is twice its radius).\nSee also: Creature.moveAbs" },
     
    3030        { "bboxSize", 0, PARAM_READONLY | PARAM_NOSTATIC, "Bounding box size", "oXYZ", GETONLY(bboxsize) },
    3131        { "numcheckpoints", 0, PARAM_DONTSAVE | PARAM_READONLY | PARAM_NOSTATIC, "Number of checkpoints", "d", GETONLY(numcheckpoints) },
    32         { "getCheckpoint", 0, PARAM_USERHIDDEN | PARAM_NOSTATIC, "getCheckpoint", "p oModel(d index)", PROCEDURE(p_getcheckpoint),
     32        { "getCheckpoint", 0, PARAM_READONLY | PARAM_USERHIDDEN | PARAM_NOSTATIC, "getCheckpoint", "p oModel(d index)", PROCEDURE(p_getcheckpoint),
    3333        "Checkpoint Model objects are only valid as long as the parent Model object exists.\n"
    3434        "See also: Model.newWithCheckpoints()\n\n"
  • cpp/frams/model/similarity/measure-greedy.cpp

    r1073 r1158  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2021  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
    55#include "measure-greedy.h"
     6#include <cstdlib> //std::qsort()
    67#include <assert.h>
    78
  • cpp/frams/neuro/impl/neuroimpl-fuzzy.cpp

    r1130 r1158  
    55#include "neuroimpl-fuzzy.h"
    66#include "neuroimpl-fuzzy-f0.h"
     7#include <algorithm>
    78
    89int NI_FuzzyNeuro::countOuts(const Model *m, const Neuro *fuzzy)
  • cpp/frams/util/extvalue.h

    r1130 r1158  
    4343class ExtObject
    4444{
    45         int subtype;                    //< 0/1=Generic/DPC Object,  0/2=Standalone/Shared Param
     45        int subtype;                    //< 0/1=Generic/DPC Object,  0/2=Standalone/Shared Param,  0/4=RW/Readonly
    4646        void incref() const;
    4747        void decref() const;
     
    7373        void setEmpty() { decref(); subtype = 0; param = NULL; object = NULL; }
    7474        int isEmpty() const { return !param; }
     75        bool isReadonly() const {return (subtype&4)!=0;}
     76        void setReadonly(bool ro) {subtype=(subtype&~4)|(ro?4:0);}
    7577        static const ExtObject& empty() { static const ExtObject e((ParamInterface*)NULL); return e; }
    7678        ExtObject(const ExtObject& src) { DEBUG_EXTOBJECT("(const&)"); src.incref(); copyFrom(src); }
     
    188190        void setInvalid() { setEmpty(); type = TInvalid; }
    189191        void setError(const SString& msg);
     192        bool isReadonly() const {return (type==TObj) && odata().isReadonly();}
     193        void setReadonly(bool ro) {if (type==TObj) odata().setReadonly(ro);}
    190194        bool makeUnique() { return (type == TObj) && odata().makeUnique(); } //< @return false if nothing has changed
    191195        ExtPType getType() const { return type; }
  • cpp/frams/vm/classes/3dobject.cpp

    r951 r1158  
    2020                { "new", 0, 0, "create new XYZ object", "p oXYZ(f x,f y,f z)", PROCEDURE(p_new), "3D vectors objects can be also created using the (x,y,z) notation, i.e. var v=(1,2,3) is the same as var v=XYZ.new(1,2,3);", },
    2121                { "newFromVector", 0, 0, "create new XYZ object", "p oXYZ(oVector)", PROCEDURE(p_newFromVector), "used for deserialization" },
    22                 { "clone", 0, PARAM_NOSTATIC, "create new XYZ object copying the coordinates", "p oXYZ()", PROCEDURE(p_clone), "Note: copying object references does not create new objects. Use clone() if a new object is needed.\n\nExample:\nvar o1=(1,2,3), o2=o1, o3=o1.clone();\no1.y=9999;\n//o2 is now (1,9999,3) but o3 is still (1,2,3)", },
     22                { "clone", 0, PARAM_READONLY | PARAM_NOSTATIC, "create new XYZ object copying the coordinates", "p oXYZ()", PROCEDURE(p_clone), "Note: copying object references does not create new objects. Use clone() if a new object is needed.\n\nExample:\nvar o1=(1,2,3), o2=o1, o3=o1.clone();\no1.y=9999;\n//o2 is now (1,9999,3) but o3 is still (1,2,3)", },
    2323                { "set", 0, PARAM_NOSTATIC, "set (copy) coordinates from another XYZ object", "p(oXYZ)", PROCEDURE(p_set), },
    2424                { "set3", 0, PARAM_NOSTATIC, "set individual 3 coordinates", "p(f x,f y,f z)", PROCEDURE(p_set3), },
     
    3232                { "rotate", 0, PARAM_NOSTATIC, "rotate using Orient object", "p(oOrient)", PROCEDURE(p_rotate), },
    3333                { "revRotate", 0, PARAM_NOSTATIC, "reverse rotate using Orient object", "p(oOrient)", PROCEDURE(p_revrotate), },
    34                 { "get", 0, PARAM_NOSTATIC, "get one of coordinates", "p f(d index)", PROCEDURE(p_get), "this function makes the XYZ objects \"indexable\" (so you can use [] for accessing subsequent fields, like in Vector)", },
     34                { "get", 0, PARAM_READONLY | PARAM_NOSTATIC, "get one of coordinates", "p f(d index)", PROCEDURE(p_get), "this function makes the XYZ objects \"indexable\" (so you can use [] for accessing subsequent fields, like in Vector)", },
    3535                { 0, 0, 0, },
    3636        };
  • cpp/frams/vm/classes/collectionobj.cpp

    r1130 r1158  
    3131        { "size", 0, PARAM_READONLY | PARAM_NOSTATIC, "Element count", "d", GETONLY(size), },
    3232        { "remove", 0, PARAM_NOSTATIC, "Remove at position", "p(d position)", PROCEDURE(p_remove), },
    33         { "get", 0, PARAM_NOSTATIC, "Get value at position", "p x(d position)", PROCEDURE(p_get), "object[position] can be always used instead of object.get(position)" },
     33        { "get", 0, PARAM_READONLY | PARAM_NOSTATIC, "Get value at position", "p x(d position)", PROCEDURE(p_get), "object[position] can be always used instead of object.get(position)" },
    3434        { "set", 0, PARAM_NOSTATIC, "Set value at position", "p(d position,x value)", PROCEDURE(p_set), "object[position]=value can be always used instead of object.set(position,value)" },
    3535        { "insert", 0, PARAM_NOSTATIC, "Insert value at position", "p(d position,x value)", PROCEDURE(p_insert), },
    3636        { "add", 0, PARAM_NOSTATIC, "Append at the end", "p(x value)", PROCEDURE(p_add), },
    37         { "find", 0, PARAM_NOSTATIC, "Find", "p d(x value)", PROCEDURE(p_find), "returns the element index or -1 if not found" },
     37        { "find", 0, PARAM_READONLY | PARAM_NOSTATIC, "Find", "p d(x value)", PROCEDURE(p_find), "returns the element index or -1 if not found" },
    3838        { "avg", 0, PARAM_READONLY | PARAM_NOSTATIC, "Average", "x", GETONLY(avg) },
    3939        { "stdev", 0, PARAM_READONLY | PARAM_NOSTATIC, "Standard deviation", "x", GETONLY(stdev), "=sqrt(sum((element[i]-avg)^2)/(size-1)) which is estimated population std.dev. from sample std.dev." },
     
    4242        { "sort", 0, PARAM_NOSTATIC, "Sort elements (in place)", "p(oFunctionReference comparator)", PROCEDURE(p_sort), "comparator can be null, giving the \"natural\" sorting order (depending on element type), otherwise it must be a function reference obtained from the 'function' operator.\n\nExample:\nfunction compareLastDigit(a,b) {return (a%10)<(b%10);}\nvar v=[16,23,35,42,54,61];\nv.sort(function compareLastDigit);" },
    4343        { "iterator", 0, PARAM_NOSTATIC | PARAM_READONLY, "Iterator", "o", GETONLY(iterator), },
    44         { "clone", 0, PARAM_NOSTATIC, "Create a clone", "p oVector()", PROCEDURE(p_clone), "The resulting clone is a shallow copy (contains the same object references as the original). A deep copy can be obtained through serialization: String.deserialize(String.serialize(object));" },
     44        { "clone", 0, PARAM_READONLY | PARAM_NOSTATIC, "Create a clone", "p oVector()", PROCEDURE(p_clone), "The resulting clone is a shallow copy (contains the same object references as the original). A deep copy can be obtained through serialization: String.deserialize(String.serialize(object));" },
    4545        { 0, 0, 0, },
    4646};
     
    7272        { "size", 0, PARAM_NOSTATIC | PARAM_READONLY, "Element count", "d", GETONLY(size), },
    7373        { "remove", 0, PARAM_NOSTATIC, "Remove", "p(x key)", PROCEDURE(p_remove), "Removes the named or indexed element (depending on the argument type: string or int)." },
    74         { "get", 0, PARAM_NOSTATIC, "Get element", "p x(x key)", PROCEDURE(p_get), "Retrieves the named or indexed element (depending on the argument type: string or int). Accessing nonexistent keys is an error (use hasKey() if necessary).\nobject.get(key) can be shortened to object[key]." },
    75         { "getKey", 0, PARAM_NOSTATIC, "Get a key", "p s(d index)", PROCEDURE(p_getKey), "Returns the key of the indexed element (0 <= index < size)." },
    76         { "hasKey", 0, PARAM_NOSTATIC, "Check if key exists", "p d(s key)", PROCEDURE(p_hasKey), "Returns 1 (interpreted as true) if dictionary contains the supplied key, or 0 (false) otherwise.\nExample:\n   if (obj.hasKey(\"a\"))\n      x = obj->a;" },
     74        { "get", 0, PARAM_READONLY | PARAM_NOSTATIC, "Get element", "p x(x key)", PROCEDURE(p_get), "Retrieves the named or indexed element (depending on the argument type: string or int). Accessing nonexistent keys is an error (use hasKey() if necessary).\nobject.get(key) can be shortened to object[key]." },
     75        { "getKey", 0, PARAM_READONLY | PARAM_NOSTATIC, "Get a key", "p s(d index)", PROCEDURE(p_getKey), "Returns the key of the indexed element (0 <= index < size)." },
     76        { "hasKey", 0, PARAM_READONLY | PARAM_NOSTATIC, "Check if key exists", "p d(s key)", PROCEDURE(p_hasKey), "Returns 1 (interpreted as true) if dictionary contains the supplied key, or 0 (false) otherwise.\nExample:\n   if (obj.hasKey(\"a\"))\n      x = obj->a;" },
    7777        { "set", 0, PARAM_NOSTATIC, "Set element", "p x(x key,x value)", PROCEDURE(p_set), "Set element value for the specified key or index (depending on the argument type: string or int).\n"
    7878        "Returns the value previously associated with the given key (or index).\n"
     
    8181        "  var old_value=object.set(\"key\",new_value); //'old_value' gets the value previously associated with \"key\"\n"
    8282        "  var x=object[\"key\"]=new_value; //'x' becomes 'new_value', consistently with the semantics of the assignment operator. The value previously associated with \"key\" is lost." },
    83         { "find", 0, PARAM_NOSTATIC, "Find", "p x(x value)", PROCEDURE(p_find), "Returns the element key or null if not found." },
     83        { "find", 0, PARAM_READONLY | PARAM_NOSTATIC, "Find", "p x(x value)", PROCEDURE(p_find), "Returns the element key or null if not found." },
    8484        { "new", 0, 0, "Create a Dictionary", "p oDictionary()", STATICPROCEDURE(p_new), "Empty directory can be also created using the {} expression." },
    8585        { "toString", 0, PARAM_READONLY | PARAM_NOSTATIC, "Textual form", "s", GETONLY(toString), },
    86         { "clone", 0, PARAM_NOSTATIC, "Create a clone", "p oDictionary()", PROCEDURE(p_clone), "The resulting clone is a shallow copy (contains the same object references as the original). A deep copy can be obtained through serialization: String.deserialize(String.serialize(object));" },
     86        { "clone", 0, PARAM_READONLY | PARAM_NOSTATIC, "Create a clone", "p oDictionary()", PROCEDURE(p_clone), "The resulting clone is a shallow copy (contains the same object references as the original). A deep copy can be obtained through serialization: String.deserialize(String.serialize(object));" },
    8787        { "assign", 0, PARAM_NOSTATIC, "Assign from another object", "p(x)", PROCEDURE(p_assign), "Replaces current dictionary with dictionary contents from another object." },
    8888        { "iterator", 0, PARAM_NOSTATIC | PARAM_READONLY, "Iterator", "o", GETONLY(iterator), },
     
    9999
    100100VectorObject::VectorObject(Pt3D &pt)
    101         :readonly(0), owndata(1)
     101        :owndata(1)
    102102{
    103103        set_or_insert(0, ExtValue(pt.x), false);
     
    119119void VectorObject::p_remove(PARAMPROCARGS)
    120120{
    121         if (readonly) return;
    122121        int i = args->getInt();
    123122        if (!listIndexCheck(&data, i, "VectorObject", "remove")) return;
     
    270269        VMachine *vm;
    271270        VMVEComparator(VMachine::JumpTargetObject *_jto) :jto(_jto), vm(jto->vm) {}
    272 #ifdef QSORT_R_USING_QSORT_S
     271#ifdef QSORT_R_THIS_FIRST
    273272        static int compare(void* _this, const void *a, const void *b);
    274273        bool operator()(const ExtValue *a, const ExtValue *b) { return compare(this,&a,&b) == ExtValue::ResultLower; }
     
    279278};
    280279
    281 #ifdef QSORT_R_USING_QSORT_S
     280#ifdef QSORT_R_THIS_FIRST
    282281int VMVEComparator::compare(void* _this, const void *a, const void *b)
    283282#else
     
    324323                std::sort(first, first + data.size(), cmp); //no qsort_r() or equivalent on Android (yet)
    325324#else
    326                 qsort_r(first, data.size(), sizeof(ExtValue*), cmp.compare, &cmp);
     325                CALL_QSORT_R(first, data.size(), sizeof(ExtValue*), cmp.compare, &cmp);
    327326#endif
    328327        }
  • cpp/frams/vm/classes/collectionobj.h

    r929 r1158  
    1616public:
    1717        SList data;
    18         unsigned int readonly : 1, owndata : 1;
     18        unsigned int owndata : 1;
    1919        void clear();
    2020        ExtValue *get(int i) { return (ExtValue*)data.get(i); }
     
    2424        static Param par;
    2525        VectorObject(Pt3D& pt);
    26         VectorObject() :readonly(0), owndata(1) {}
     26        VectorObject() :owndata(1) {}
    2727        ~VectorObject() { clear(); }
    2828        static Param& getStaticParam() { return par; }
    2929#define STATRICKCLASS VectorObject
    30         PARAMPROCDEF(p_clear) { if (readonly) return; clear(); }
     30        PARAMPROCDEF(p_clear) { clear(); }
    3131        PARAMGETDEF(size) { arg1->setInt(data.size()); }
    3232        PARAMGETDEF(avg);
     
    3636        PARAMPROCDEF(p_get);
    3737        PARAMPROCDEF(p_find);
    38         PARAMPROCDEF(p_set) { if (!readonly) set_or_insert(arg1[1].getInt(), arg1[0], false); }
    39         PARAMPROCDEF(p_add) { if (readonly) return; /*ExtValue tmp; get_toString(&tmp); printf("%s += %s",(const char*)tmp.getString(),(const char*)arg1[0].getString());*/ data += new ExtValue(arg1[0]); /*get_toString(&tmp); printf(" -> %s\n",(const char*)tmp.getString());*/ arg2->setInt(data.size() - 1); }
    40         PARAMPROCDEF(p_insert) { if (!readonly) set_or_insert(arg1[1].getInt(), arg1[0], true); }
     38        PARAMPROCDEF(p_set) { set_or_insert(arg1[1].getInt(), arg1[0], false); }
     39        PARAMPROCDEF(p_add) { data += new ExtValue(arg1[0]); arg2->setInt(data.size() - 1); }
     40        PARAMPROCDEF(p_insert) { set_or_insert(arg1[1].getInt(), arg1[0], true); }
    4141        PARAMGETDEF(toString);
    4242        PARAMPROCDEF(p_sort);
  • cpp/frams/vm/classes/genoobj.cpp

    r999 r1158  
    2323        "-1 = validity is not known. This is a transient state. The value of \"is_valid\" will never be -1 when read. It is safe to treat is_valid as boolean in statements like \"if (g.is_valid) ...\". Setting \"is_valid=-1\" will make it 0 or 1 again. This third state (-1) is only needed for loading Genotype objects from files where the \"is_valid\" field might not be present."
    2424        },
    25         { "getConverted", 0, PARAM_NOSTATIC, "Get converted genotype", "p oGeno(s format)", PROCEDURE(p_getconvert), },
    26         { "getConvertedWithCheckpoints", 0, PARAM_NOSTATIC, "Get converted genotype", "p oGeno(s format)", PROCEDURE(p_getconvert_ch), "See also Model.newWithCheckpoints()" },
     25        { "getConverted", 0, PARAM_READONLY | PARAM_NOSTATIC, "Get converted genotype", "p oGeno(s format)", PROCEDURE(p_getconvert), },
     26        { "getConvertedWithCheckpoints", 0, PARAM_READONLY | PARAM_NOSTATIC, "Get converted genotype", "p oGeno(s format)", PROCEDURE(p_getconvert_ch), "See also Model.newWithCheckpoints()" },
    2727        { "f0genotype", 0, PARAM_NOSTATIC | PARAM_READONLY, "f0 genotype", "s 1", GETONLY(f0genotype), "converted to f0 genotype", },
    2828        { "new", 0, 0, "create new empty object", "p oGeno()", PROCEDURE(p_new), },
Note: See TracChangeset for help on using the changeset viewer.