i have a list of objects called gobletinv that i want to add and remove objects from
right now to add a new object I've just done this
gobletinv(gobletpointer).mainstattype = MST.Text
gobletinv(gobletpointer).mainstatvalue = MSV.Text
gobletinv(gobletpointer).substat1type = ST1.Text
gobletinv(gobletpointer).substat1value = SV1.Text
gobletinv(gobletpointer).substat2type = ST2.Text
gobletinv(gobletpointer).substat2value = SV2.Text
gobletinv(gobletpointer).substat3type = ST3.Text
gobletinv(gobletpointer).substat3value = SV3.Text
gobletinv(gobletpointer).substat4type = ST4.Text
gobletinv(gobletpointer).substat4value = SV4.Text
gobletpointer += 1
i currently have no idea how i would remove an object from this list
Let's assume that the type your collection holds is called Stat. Let's also assume that gobletpointer is an Integer with an initial value of 0.
Each line where you are referencing the collection, you start it off with:
gobletinv(gobletpointer)
What this does is get the item from the collection at a given index.
So right now when you set the various property values to their respective TextBox value, you are overwriting the existing item in the collection.
If you wanted to add a new item to the collection, you would use the Add method (documentation). For example:
gobletinv.Add(New Stat() With {
mainstattype = MST.Text,
mainstatvalue = MSV.Text
substat1type = ST1.Text,
substat1value = SV1.Text,
substat2type = ST2.Text,
substat2value = SV2.Text,
substat3type = ST3.Text,
substat3value = SV3.Text,
substat4type = ST4.Text,
substat4value = SV4.Text
})
Now if you wanted to remove the object from the collection, it depends on how you want to remove it. But here is an example of leveraging the RemoveAt method (documentation) to remove the first record from the collection:
gobletinv.RemoveAt(0)
Update: This is a fiddle demonstrating how to add/remove items to the collection. https://dotnetfiddle.net/c0W6yS
I would like to save all my variables and dual variables of my finished lp-optimization in an efficient manner. My current solution works, but is neither elegant nor suited for larger optimization programs with many variables and constraints because I define and push! every single variable into DataFrames separately. Is there a way to iterate through the variables using all_variables() and all_constraints() for the duals? While iterating, I would like to push the results into DataFrames with the variable index name as columns and save the DataFrame in a Dict().
A conceptual example would be for variables:
Result_vars = Dict()
for vari in all_variables(Model)
Resul_vars["vari"] = DataFrame(data=[indexval(vari),value(vari)],columns=[index(vari),"Value"])
end
An example of the appearance of the declared variable in JuMP and DataFrame:
#variable(Model, p[t=s_time,n=s_n,m=s_m], lower_bound=0,base_name="Expected production")
And Result_vars[p] shall approximately look like:
t,n,m,Value
1,1,1,50
2,1,1,60
3,1,1,145
Presumably, you could go something like:
x = all_variables(model)
DataFrame(
name = variable_name.(x),
Value = value.(x),
)
If you want some structure more complicated, you need to write custom code.
T, N, M, primal_solution = [], [], [], []
for t in s_time, n in s_n, m in s_m
push!(T, t)
push!(N, n)
push!(M, m)
push!(primal_solution, value(p[t, n, m]))
end
DataFrame(t = T, n = N, m = M, Value = primal_solution)
See here for constraints: https://jump.dev/JuMP.jl/stable/constraints/#Accessing-constraints-from-a-model-1. You want something like:
for (F, S) in list_of_constraint_types(model)
for con in all_constraints(model, F, S)
#show dual(con)
end
end
Thanks to Oscar, I have built a solution that could help to automatize the extraction of results.
The solution is build around a naming convention using base_name in the variable definition. One can copy paste the variable definition into base_name followed by :. E.g.:
#variable(Model, p[t=s_time,n=s_n,m=s_m], lower_bound=0,base_name="p[t=s_time,n=s_n,m=s_m]:")
The naming convention and syntax can be changed, comments can e.g. be added, or one can just not define a base_name. The following function divides the base_name into variable name, sets (if needed) and index:
function var_info(vars::VariableRef)
split_conv = [":","]","[",","]
x_str = name(vars)
if occursin(":",x_str)
x_str = replace(x_str, " " => "") #Deletes all spaces
x_name,x_index = split(x_str,split_conv[1]) #splits raw variable name+ sets and index
x_name = replace(x_name, split_conv[2] => "")
x_name,s_set = split(x_name,split_conv[3])#splits raw variable name and sets
x_set = split(s_set,split_conv[4])
x_index = replace(x_index, split_conv[2] => "")
x_index = replace(x_index, split_conv[3] => "")
x_index = split(x_index,split_conv[4])
return (x_name,x_set,x_index)
else
println("Var base_name not properly defined. Special Syntax required in form var[s=set]: ")
end
end
The next functions create the columns and the index values plus columns for the primal solution ("Value").
function create_columns(x)
col_ind=[String(var_info(x)[2][col]) for col in 1:size(var_info(x)[2])[1]]
cols = append!(["Value"],col_ind)
return cols
end
function create_index(x)
col_ind=[String(var_info(x)[3][ind]) for ind in 1:size(var_info(x)[3])[1]]
index = append!([string(value(x))],col_ind)
return index
end
function create_sol_matrix(varss,model)
nested_sol_array=[create_index(xx) for xx in all_variables(model) if varss[1]==var_info(xx)[1]]
sol_array=hcat(nested_sol_array...)
return sol_array
end
Finally, the last function creates the Dict which holds all results of the variables in DataFrames in the previously mentioned style:
function create_var_dict(model)
Variable_dict=Dict(vars[1]
=>DataFrame(Dict(vars[2][1][cols]
=>create_sol_matrix(vars,model)[cols,:] for cols in 1:size(vars[2][1])[1]))
for vars in unique([[String(var_info(x)[1]),[create_columns(x)]] for x in all_variables(model)]))
return Variable_dict
end
When those functions are added to your script, you can simply retrieve all the solutions of the variables after the optimization by calling create_var_dict():
var_dict = create_var_dict(model)
Be aware: they are nested functions. When you change the naming convention, you might have to update the other functions as well. If you add more comments you have to avoid using [, ], and ,.
This solution is obviously far from optimal. I believe there could be a more efficient solution falling back to MOI.
I have an object assigned to a variable bio. I just want to return the number of objects assigned to bio (in this case 1).
var bio = {
"name" : "Dave Smith",
"role" : "Web developer",
};
I can find the number of key value pairs but I just want the number of objects.
New at this so not sure if this makes sense.
Is it even possible to have multiple objects in a variable?
any help appreciated.
You have two questions here (I assume you use javascript):
How to know how many objects are assigned to a variable?
You need to do .length on the object. Note that this will work only on something that can be enumerated e.g. array.
var a = {foo: 'bar'};
a.length // undefined
var b = [{foo: 'bar'}];
b.length // 1
How to store multiple objects inside a variable
You need to use arrays like so: var bio = [{name: 'foo'}, {name: 'bar'}];
I have 133 variables on income (each variable represents a group). I want the Gini coefficients of all these groups, so I use ineqdeco in Stata. I can't compute all these coefficients by hand so I created a for loop:
gen sgini = .
foreach var of varlist C07-V14 {
forvalue i=1/133 {
ineqdeco `var'
replace sgini[i] = $S_gini
}
}
Also tried changing the order:
foreach var of varlist C07-V14 {
ineqdeco `var'
forvalue i=1/133 {
replace sgini[i] = $S_gini
}
}
And specifying i beforehand:
gen i = 1
foreach var of varlist C07-V14 {
ineqdeco `var'
replace sgini[i] = $S_gini
replace i = i+1
}
}
I don't know if this last method works anyway.
In all cases I get the error: weight not allowed r(101). I don't know what this means, or what to do. Basically, I want to compute the Gini coefficient of all 133 variables, and store these values in a vector of length 133, so a single variable with all the coefficients stored in it.
Edit: I found that the error has to do with the replace command. I replaced this line with:
replace sgini = $S_gini in `i'
But now it does not "loop", so I get the first value in all entries of sgini.
There is no obvious reason for your inner loop. If you have no more variables than observations, then this might work:
gen sgini = .
gen varname = ""
local i = 1
foreach var of varlist C07-V14 {
ineqdeco `var'
replace sgini = $S_gini in `i'
replace varname = "`var'" in `i'
local i = `i' + 1
}
The problems evident in your code (seem to) include:
Confusion between variables and local macros. If you have much experience with other languages, it is hard to break old mental habits. (Mata is more like other languages here.)
Not being aware that a loop over observations is automatic. Or perhaps not seeing that there is just a single loop needed here, the twist being that the loop over variables is easy but your concomitant loop over observations needs to be arranged with your own code.
Putting a subscript on the LHS of a replace. The [] notation is reserved for weights but is illegal there in any case. To find out about weights, search weights or help weight.
Note that with this way of recording results, the Gini coefficients are not aligned with anything else. A token fix for that is to record the associated variable names alongside, as done above.
A more advanced version of this solution would be to use postfile to save to a new dataset.
I'm trying to have a class that hold a array and use that class in some COM calls (I makes using C#).
So, I've got my classes like this:
DEFINE CLASS Logistics_Columns AS Session OLEPUBLIC
DIMENSION COLUMNS_ARRAY[1]
DIMENSION COLUMNS_ARRAY_COMATTRIB(4)
COLUMNS_ARRAY_COMATTRIB(1) = 0
COLUMNS_ARRAY_COMATTRIB(2) = "COLUMNS_ARRAY"
COLUMNS_ARRAY_COMATTRIB(3) = "COLUMNS_ARRAY"
COLUMNS_ARRAY_COMATTRIB(4) = "Array"
ENDDEFINE
DEFINE CLASS Logistics_Column AS Session OLEPUBLIC
COLUMN_NAME = .NULL.
DIMENSION COLUMN_NAME_COMATTRIB(4)
COLUMN_NAME_COMATTRIB(1) = 0
COLUMN_NAME_COMATTRIB(2) = "COLUMN_NAME"
COLUMN_NAME_COMATTRIB(3) = "COLUMN_NAME"
COLUMN_NAME_COMATTRIB(4) = "Character"
COLUMN_TYPE = .NULL.
DIMENSION COLUMN_TYPE_COMATTRIB(4)
COLUMN_TYPE_COMATTRIB(1) = 0
COLUMN_TYPE_COMATTRIB(2) = "COLUMN_TYPE"
COLUMN_TYPE_COMATTRIB(3) = "COLUMN_TYPE"
COLUMN_TYPE_COMATTRIB(4) = "Character"
COLUMN_WIDTH = .NULL.
DIMENSION COLUMN_WIDTH_COMATTRIB(4)
COLUMN_WIDTH_COMATTRIB(1) = 0
COLUMN_WIDTH_COMATTRIB(2) = "COLUMN_WIDTH"
COLUMN_WIDTH_COMATTRIB(3) = "COLUMN_WIDTH"
COLUMN_WIDTH_COMATTRIB(4) = "Integer"
COLUMN_PRECISION = .NULL.
DIMENSION COLUMN_PRECISION_COMATTRIB(4)
COLUMN_PRECISION_COMATTRIB(1) = 0
COLUMN_PRECISION_COMATTRIB(2) = "COLUMN_PRECISION"
COLUMN_PRECISION_COMATTRIB(3) = "COLUMN_PRECISION"
COLUMN_PRECISION_COMATTRIB(4) = "Integer"
ENDDEFINE
In C# for the Logistics_Columns class, COLUMNS_ARRAY is not seen as an array.
Yet or the Logistics_Column class all 4 properties are correctly seen as string or integer.
I guess "Array" (COLUMNS_ARRAY_COMATTRIB(4) = "Array")isn't the right literal value to indicate an array.
But then, what is?
As planned I created a custom collection wrapper.
It's basically a foxpro class of type Session OLEPUBLIC which store a Collection and wraps its methods.
Regarding the performance I think it adds some noticeable overhead, but it's the best method I could eventually come with.