Есть symantec c++ 7.5 там эта IDE. Если сильно хочется то можно и dmc использовать. А вот действительно редкий зверь это DOS/16M тот что в опциях -mr (Rational 286 DOS extender - obsolute)
А вот интересно если у всех провайдеров стоят ТСПУ что что мешает получать сертификаты у lets encrypt для любого сайта который хостится у такого провайдера, ведь подтвердить "владение сайтом" в такой ситуации не состовляет никаких проблем. И потом mit в полный рост и никто не заметит пока не сравнит сертификат с сайта через инет с тем что насамом деле на сайте используется. Так то идея была хорошая. Но в современных реалиях она полностью дырявая. И сокращение срока действия сертификата никак этому не поможет. А вот DNS-PERSIST-01 уже что-то, но по тойже схеме можно и DNS записи подменять.
ps: тут даже когда на год выдают сертификат, умудряются про него забыть https://br.fas.gov.ru/
Интересно что они будут делать с этими вычислительными мощностями когда они обесценятся? То есть затраты будут выше прибыли. Ведь никакой созидательной работы эти мощности по большому счету не производят. Интересно как долго эта пирамида еще протянет.
Что главная цель платформы выкачивание денег из родителей, а обучение это так для прикрытия. Бизнес, ничего личного. Да и эффективность такого обучения крайне сомнительна. Более того постоянный насильный загон всех школьников туда, сразу наводит на плохие мысли. Ведь если загоняют, то значит самостоятельно туда идти не хотят. Значит есть причины.
Еще и страты хотят внедрить, что бы уж нормальная такая сегригация была. Для низших каст электонное обЫчении на цифровых платформах с ИИ, для высших обучение с учителем. Вобщем идей у рулевых много, но они какие-то все не здоровые. При всей этой движухе, денег на повышение зарплат учетилям почему-то нет. Может это неспроста.
Задумываться можно, но ситуация горорит что одних дум не достаточно. Лучше запустить 10000 своих спутников, и пусть они будут поддерживать равновесие. Чем выражать озабоченность и потом огрести в одни ворота.
«Блокнот» давно утратил простоту, превратившись в перегруженное приложение ..., а после удаления WordPad в 2024 году пользователи окончательно лишились...
Видимо даже разработчики в микрософт не готовы пользоваться "перегруженными приложениями", поэтому в тихоря добавляют не перегруженные. Консольный текстовый редактор нужен при подключении по ssh, но тогда уж лучше vim
ps: если установть dosbox то 16битные edit и qedit работают на чем угодно
Иногда в С++ не хватает каких-то фич, которые есть в других языках. Мне, например, не хватает preperties из C#
А нехватает для чего? Что бы можно было по имени обращаться с свойствам класса? Что бы можно было отслеживать измениния? Или просто привыкли и скучаете? Если не нравиться синтаксис, так кто мешает сначала все значения сложить в переменные выполнить выражение и положить результат обратно?
Я бы предложил сделать отдельный класс для доступа к полям класса и использовать его. Что то такого вида:
пример
prop.h
#include <stdarg.h>
namespace PropNames {
enum Op { Get,Set,GetConstRef,Swap,GetName,GetType,FindByName };
// Get can convert values
// Set can convert values
// GetConstRef only for reading, can't convert
// Swap - can't convert exchange only same types
enum { NoName=-1 };
enum Types { NoType=-1,TypeInt,TypeDouble };
template<class T>int type(T&);
template<> int type(int&) { return TypeInt; }
template<> int type(double&) { return TypeDouble; }
const char* type_name(int type);
int prop_def_op(int &v,const char* name,int op,
int type,void* data,int size,int index);
int prop_def_op(double &v,const char* name,int op,
int type,void* data,int size,int index);
}
struct Prop_s {
typedef int (*op_fn)
(void* ctx,int name,int op,int type,void* data,int size,int index);
void *ctx; op_fn op;
};
struct Prop : Prop_s {
Prop(op_fn op,void *ctx) { this->ctx=ctx; this->op=op; }
template<class T>Prop& get(int name,T& value,int index=0) {
int rc=op(ctx,name,PropNames::Get,PropNames::type(value),
(void*)&value,sizeof(value),index);
if (rc) throw_op("get",name,index);
return *this;
}
template<class T>Prop& set(int name,T value,int index=0) {
int rc=op(ctx,name,PropNames::Set,PropNames::type(value),
(void*)&value,sizeof(value),index);
if (rc) throw_op("set",name,index);
return *this;
}
template<class T>Prop& swap(int name,T& value,int index=0) {
int rc=op(ctx,name,PropNames::Swap,PropNames::type(value),
(void*)&value,sizeof(value),index);
if (rc) throw_oprt("swap",name,index,PropNames::type(value));
return *this;
}
template<class T>const T& ref(int name,int index=0) {
T *value=0;
int rc=op(ctx,name,PropNames::GetConstRef,PropNames::type(*value),
(void*)&value,sizeof(value),index);
if (!value) throw_oprt("ref",name,index,PropNames::type(*(T*)0));
if (rc) throw_op("ref",name,index);
return *value;
}
const char* name(int name) {
const char* value="?";
op(ctx,name,PropNames::GetName,PropNames::NoType,
(void*)&value,sizeof(value),0);
return value;
}
int type(int name) {
return op(ctx,name,PropNames::GetType,PropNames::NoType,0,0,0);
}
const char* type_name(int name) {
return PropNames::type_name(type(name));
}
int find(const char* name) {
return op(ctx,PropNames::NoName,PropNames::FindByName,
PropNames::NoType,(void*)name,-1,0);
}
template<class T>Prop& get(const char *name,T& value,int index=0) {
int iname=find(name);
if (iname==PropNames::NoName) throw_error("get(?'%s')",name);
int rc=op(ctx,iname,PropNames::Get,PropNames::type(value),
(void*)&value,sizeof(value),index);
if (rc) throw_op("get",name,index);
return *this;
}
template<class T>Prop& set(const char *name,T value,int index=0) {
int iname=find(name);
if (iname==PropNames::NoName) throw_error("set(?'%s')",name);
int rc=op(ctx,iname,PropNames::Set,PropNames::type(value),
(void*)&value,sizeof(value),index);
if (rc) throw_op("set",name,index);
return *this;
}
template<class T>Prop& swap(const char *name,T& value,int index=0) {
int iname=find(name);
if (iname==PropNames::NoName) throw_error("swap(?'%s')",name);
int rc=op(ctx,iname,PropNames::Swap,PropNames::type(value),
(void*)&value,sizeof(value),index);
if (rc) throw_oprt("swap",name,index,PropNames::type(value));
return *this;
}
template<class T>const T& ref(const char *name,int index=0) {
int iname=find(name);
if (iname==PropNames::NoName) throw_error("ref(?'%s')",name);
T *value=0;
int rc=op(ctx,iname,PropNames::GetConstRef,PropNames::type(*value),
(void*)&value,sizeof(value),index);
if (!value) throw_oprt("ref",name,index,PropNames::type(*(T*)0));
if (rc) throw_op("ref",name,index);
return *value;
}
void throw_error(const char* msg,...);
void vthrow_error(const char* msg,va_list v);
void throw_op(const char* op_name,int name,int index);
void throw_op(const char* op_name,const char* name,int index);
void throw_oprt(const char* op_name,int name,int index,int rtype);
void throw_oprt(const char* op_name,const char *name,int index,int rtype);
};
prop.cpp
#include "prop.h"
#include <stdio.h>
#include <string.h>
void Prop::vthrow_error(const char* msg,va_list v) {
printf("ERROR: "); vprintf(msg,v); printf("\n");
throw this;
}
void Prop::throw_error(const char* msg,...) {
va_list v; va_start(v,msg);
vthrow_error(msg,v);
va_end(v);
}
const char* PropNames::type_name(int type) {
switch(type) {
case NoType: return "NoType";
case TypeInt: return "int";
case TypeDouble: return "double";
}
return "?";
}
void Prop::throw_op(const char* op_name,int name,int index) {
if (index)
throw_error("%s(%d=%s[%d])",op_name,name,this->name(name),index);
throw_error("%s(%d=%s)",op_name,name,this->name(name));
}
void Prop::throw_op(const char* op_name,const char* name,int index) {
if (index) throw_error("%s('%s'[%d])",op_name,name,index);
throw_error("%s('%s')",op_name,name);
}
void Prop::throw_oprt(const char* op_name,int name,int index,int rtype) {
int vtype=type(name);
if (rtype!=vtype) {
const char* rtype_name=PropNames::type_name(rtype);
const char* vtype_name=PropNames::type_name(vtype);
throw_error("%s(%d:'%s') %s<->%s ?",
op_name,name,this->name(name),vtype_name,rtype_name);
}
if (index)
throw_error("%s(%d=%s[%d])",op_name,name,this->name(name),index);
throw_error("%s(%d=%s)",op_name,name,this->name(name));
}
void Prop::throw_oprt(const char* op_name,const char *name,int index,int rtype) {
int iname=find(name);
int vtype=type(iname);
if (rtype!=vtype) {
const char* rtype_name=PropNames::type_name(rtype);
const char* vtype_name=PropNames::type_name(vtype);
throw_error("%s('%s') %s<->%s ?",
op_name,name,vtype_name,rtype_name);
}
if (index)
throw_error("%s('%s'[%d])",op_name,name,index);
throw_error("%s('%s')",op_name,name);
}
int PropNames::prop_def_op(int &v,const char* name,int op,
int type,void* data,int size,int index)
{
int ptype=PropNames::type(v);
if (op==GetType) return ptype;
if (op==GetName) {
if (size<(int)sizeof(name)) return -1;
memcpy(data,&name,sizeof(name)); return 0;
}
if (index!=0) return -1;
if (op==Set && type==TypeDouble) { // convert double->int
double vd; if (size<(int)sizeof(vd)) return -1;
memcpy(&vd,data,sizeof(vd));
int vi=vd; if (vi!=vd) return -1; // unable to convert
return prop_def_op(v,name,op,TypeInt,&vi,sizeof(vi),index);
}
if (type!=ptype) return -1;
int sz=(int)sizeof(v);
if (op==GetConstRef) sz=(int)sizeof(&v);
if (size<sz) return -1;
switch(op) {
case Get: { memcpy(data,&v,sizeof(v)); } break;
case Set: { memcpy(&v,data,sizeof(v)); } break;
case GetConstRef: { void *pv=&v; memcpy(data,&pv,sizeof(pv)); } break;
case Swap: {
//memswp(data,&v,sizeof(v));
char t[sizeof(v)];
memcpy(&t,&v,sizeof(v));
memcpy(&v,data,sizeof(v));
memcpy(data,&t,sizeof(v));
} break;
default: return -1;
}
return 0;
}
int PropNames::prop_def_op(double &v,const char* name,int op,int type,void* data,int size,int index) {
int ptype=PropNames::type(v);
if (op==GetType) return ptype;
if (op==GetName) {
if (size<(int)sizeof(name)) return -1;
memcpy(data,&name,sizeof(name)); return 0;
}
if (index!=0) return -1;
if (op==Set && type==TypeInt) { // convert int->double
int vi; if (size<(int)sizeof(vi)) return -1;
memcpy(&vi,data,sizeof(vi)); double vd=vi;
return prop_def_op(v,name,op,TypeDouble,&vd,sizeof(vd),index);
}
if (type!=ptype) return -1;
int sz=(int)sizeof(v);
if (op==GetConstRef) sz=(int)sizeof(&v);
if (size<sz) return -1;
switch(op) {
case Get: { memcpy(data,&v,sizeof(v)); } break;
case Set: { memcpy(&v,data,sizeof(v)); } break;
case GetConstRef: { void *pv=&v; memcpy(data,&pv,sizeof(pv)); } break;
case Swap: {
//memswp(data,&v,sizeof(v));
char t[sizeof(v)];
memcpy(&t,&v,sizeof(v));
memcpy(&v,data,sizeof(v));
memcpy(data,&t,sizeof(v));
} break;
default: return -1;
}
return 0;
}
a.h
struct A {
int x; double y;
enum { X,Y };
Prop prop() { return Prop(prop_op_ref,this); }
static A* my(void *ctx) { return (A*)ctx; }
static int prop_op_ref(void* ctx,int name,int op,
int type,void* data,int size,int index)
{ return my(ctx)->prop_op(name,op,type,data,size,index); }
int prop_op(int name,int op,int type,void* data,int size,int index);
};
a.cpp
#include "prop.h"
#include <string.h>
int A::prop_op(int name,int op,int type,void* data,int size,int index) {
using namespace PropNames;
if (op==FindByName) {
const char* req=(const char*)data;
if (strcmp(req,"X")==0) return X;
if (strcmp(req,"Y")==0) return Y;
return -1;
}
switch(name) {
case X: return prop_def_op(x,"X",op,type,data,size,index);
case Y: return prop_def_op(y,"Y",op,type,data,size,index);
}
return -1;
}
А когда нужно вычислять выражения сначала получить все поля по константным ссылкаи посчитать и положить обратно или можно забирать тяжелые данные с помощью операции обмена данных.
struct A {
int x; double y;
enum { X,Y }; // имена полей
Prop prop(); // получение доступа к полям
...
};
int main(int argc,char** argv) {
A a;
try {
Prop pa=a.prop();
pa.set("X",1e3).set("Y",2);
const int& rx=pa.ref<int>(A::X);
const double& ry=pa.ref<double>(A::Y);
int x; double y;
pa.get(A::X,x).get(A::Y,y);
printf("X=%d a.x=%d &x=%d\n",x,a.x,rx);
printf("Y=%.2f a.y=%.2f &y=%.2f\n",y,a.y,ry);
x=x+y; pa.swap("X",x);
printf("x=%d a.x=%d\n",x,a.x);
} catch(Prop*) {
printf("problem\n");
}
return 0;
}
TFlops-ы измеряются в float32, а у этой коробки float4 а для них можно все операции в таблицы сложить, более того оно умеет рязряженные матрицы, то есть может частично выкидывать данные при свёртках, что защитывается как если бы он всё матрицу влоб обрабатывал (поэтому поводу особо не переживают, просто сравнивают итоговый inference и смотрят потерю точности). Поэтому это совершенно разные flops-ы.
Он уже давно не мусор и всё более свежая винда вызывает только недоумение и вопросы куда опять всё попрятали и что из новых безопасных безопасностей и заботах о пользователях надо отключить чтобы опять всё заработало.
У них еще нет сервиса яндекс забастовка?
Сколько требуется времени чтобы записать весь доступный объём?
А как дела обстаят со структурами данных для растровой графики и линейной алгебры?
Есть symantec c++ 7.5 там эта IDE. Если сильно хочется то можно и dmc использовать.
А вот действительно редкий зверь это DOS/16M тот что в опциях -mr (Rational 286 DOS extender - obsolute)
А вот интересно если у всех провайдеров стоят ТСПУ что что мешает получать сертификаты у lets encrypt для любого сайта который хостится у такого провайдера, ведь подтвердить "владение сайтом" в такой ситуации не состовляет никаких проблем. И потом mit в полный рост и никто не заметит пока не сравнит сертификат с сайта через инет с тем что насамом деле на сайте используется. Так то идея была хорошая. Но в современных реалиях она полностью дырявая. И сокращение срока действия сертификата никак этому не поможет. А вот DNS-PERSIST-01 уже что-то, но по тойже схеме можно и DNS записи подменять.
ps: тут даже когда на год выдают сертификат, умудряются про него забыть https://br.fas.gov.ru/
Придётся шифровать сообщения и в base64 отправлять через мах. А еще лучше, по старинке, просто через email.
WhatsApp это конечно хорошо, но почему паралельно отвалилась юкасса https://detector404.ru/yukassa https://vk.com/yookassa
Интересно что они будут делать с этими вычислительными мощностями когда они обесценятся?
То есть затраты будут выше прибыли. Ведь никакой созидательной работы эти мощности по большому счету не производят. Интересно как долго эта пирамида еще протянет.
81 уровень
То есть план собрать побольше денег и положить их в резерв.
А то как-то слишком медленно он растёт последние годы. Так?
Замечательно, а теперь под ZX-spectrum
Что главная цель платформы выкачивание денег из родителей, а обучение это так для прикрытия. Бизнес, ничего личного. Да и эффективность такого обучения крайне сомнительна. Более того постоянный насильный загон всех школьников туда, сразу наводит на плохие мысли. Ведь если загоняют, то значит самостоятельно туда идти не хотят. Значит есть причины.
Еще и страты хотят внедрить, что бы уж нормальная такая сегригация была. Для низших каст электонное обЫчении на цифровых платформах с ИИ, для высших обучение с учителем. Вобщем идей у рулевых много, но они какие-то все не здоровые. При всей этой движухе, денег на повышение зарплат учетилям почему-то нет. Может это неспроста.
Это как бы намекает на некомпетентность ведомста. Может пора уже их как-то разгонять? Без ускорения оно работает не так как задумано.
Задумываться можно, но ситуация горорит что одних дум не достаточно. Лучше запустить 10000 своих спутников, и пусть они будут поддерживать равновесие. Чем выражать озабоченность и потом огрести в одни ворота.
Эти спутники смогут контролировать множество роёв дронов, по всей планете. А мы просто спокойно смотрим и радуемся. Свои почему не запускаем?
ps: глушить их практически нечем
Видимо даже разработчики в микрософт не готовы пользоваться "перегруженными приложениями", поэтому в тихоря добавляют не перегруженные.
Консольный текстовый редактор нужен при подключении по ssh, но тогда уж лучше vim
ps: если установть dosbox то 16битные edit и qedit работают на чем угодно
pps: ждём
nortonmicrosoft comanderА нехватает для чего? Что бы можно было по имени обращаться с свойствам класса? Что бы можно было отслеживать измениния? Или просто привыкли и скучаете? Если не нравиться синтаксис, так кто мешает сначала все значения сложить в переменные выполнить выражение и положить результат обратно?
Я бы предложил сделать отдельный класс для доступа к полям класса и использовать его. Что то такого вида:
пример
prop.h
prop.cpp
a.h
a.cpp
example.cpp
А когда нужно вычислять выражения сначала получить все поля по константным ссылкаи посчитать и положить обратно или можно забирать тяжелые данные с помощью операции обмена данных.
TFlops-ы измеряются в float32, а у этой коробки float4 а для них можно все операции в таблицы сложить, более того оно умеет рязряженные матрицы, то есть может частично выкидывать данные при свёртках, что защитывается как если бы он всё матрицу влоб обрабатывал (поэтому поводу особо не переживают, просто сравнивают итоговый inference и смотрят потерю точности). Поэтому это совершенно разные flops-ы.
Когда мышь наконец-то научиться перемешаться по столу самостоятельно. И откликаться на голос пользователя :)
Он уже давно не мусор и всё более свежая винда вызывает только недоумение и вопросы куда опять всё попрятали и что из новых безопасных безопасностей и заботах о пользователях надо отключить чтобы опять всё заработало.