SimScale, the leading provider of cloud-native engineering simulation software, is thrilled to announce a strategic collaboration with PTC and its Ons

SimScale and PTC Collaborate to Empower Start-Ups Using PTC Onshape with Free Access to Cloud-Native Simulation Enabling Accelerated Product Innovation | Business Wire

SimScale

simscale

Author:
(1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu);
(2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu);
(3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Table of Links Abstract Introduction & Related Work Method Analysis & Results Discussion & Conclusion References IV. DISCUSSION & CONCLUSION This study (n = 239) was conducted to explore the impact of first impressions and trustworthiness characteristics on social robot trust and acceptance. The results of the mediation analysis show that while there was no direct effect of first impressions on trust, the indirect effects of both warmth and competence on trust via the mediator trustworthiness were significant. Separating trustworthiness into its sub scales ability, benevolence and integrity run as parallel mediation confirmed that both ability and benevolence, but not integrity, produced significant indirect effects on trust. Other research [7] has documented this phenomenon and suggested that of these three sub scales, integrity only predicts trust via ability and benevolence. A serial parallel model placing integrity before ability and benevolence, which in turn predicted trust, confirmed this. Finally, a serial parallel mediation model including first impressions, trustworthiness constructs, trust and behavioral intention per the UTAUT model was devised and analyzed. All indirect effects were significant, indicating that participants whose first impression of the social robot was positive were likely to intent to use if they also perceived it as trustworthy and had trust in it. Notably, in this final model integrity was placed in parallel with ability and benevolence and produced a significant effect predicting intention to use via trust, while a prior model showed that it predicted a trust outcome only in serial with ability and benevolence, indicating that predicting intention to use may rely on all three subscales to a higher degree than trust does. This model gives evidence that stereotypical first impressions, trustworthiness, trust and use behavior are closely related and informed by each other. We recommend further investigations into how real-world interactions may influence the reported results and how contextual changes and different user segments may affect the role of trustworthiness characteristics. This paper is available on arxiv under CC 4.0 license. Author: (1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu); (2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu); (3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Author: Author: (1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu); (2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu); (3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Table of Links Abstract Introduction & Related Work Abstract Introduction & Related Work Method Method Analysis & Results Analysis & Results Discussion & Conclusion Discussion & Conclusion References References IV. DISCUSSION & CONCLUSION This study (n = 239) was conducted to explore the impact of first impressions and trustworthiness characteristics on social robot trust and acceptance. The results of the mediation analysis show that while there was no direct effect of first impressions on trust, the indirect effects of both warmth and competence on trust via the mediator trustworthiness were significant. Separating trustworthiness into its sub scales ability, benevolence and integrity run as parallel mediation confirmed that both ability and benevolence, but not integrity, produced significant indirect effects on trust. Other research [7] has documented this phenomenon and suggested that of these three sub scales, integrity only predicts trust via ability and benevolence. A serial parallel model placing integrity before ability and benevolence, which in turn predicted trust, confirmed this. Finally, a serial parallel mediation model including first impressions, trustworthiness constructs, trust and behavioral intention per the UTAUT model was devised and analyzed. All indirect effects were significant, indicating that participants whose first impression of the social robot was positive were likely to intent to use if they also perceived it as trustworthy and had trust in it. Notably, in this final model integrity was placed in parallel with ability and benevolence and produced a significant effect predicting intention to use via trust, while a prior model showed that it predicted a trust outcome only in serial with ability and benevolence, indicating that predicting intention to use may rely on all three subscales to a higher degree than trust does. This model gives evidence that stereotypical first impressions, trustworthiness, trust and use behavior are closely related and informed by each other. We recommend further investigations into how real-world interactions may influence the reported results and how contextual changes and different user segments may affect the role of trustworthiness characteristics. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Trust and Acceptance of Social Robots: Discussion & Conclusion

Author:
(1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu);
(2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu);
(3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Table of Links Abstract Introduction & Related Work Method Analysis & Results Discussion & Conclusion References III. ANALYSIS & RESULTS The research questions were investigated via a series of mediation analyses. Mediation analysis informs the relation between two variables by explaining how they are related [21]. The analysis models how a mediator variable transmits the effect of an independent variable X on a dependent variable Y. Path analysis is an extension of multiple regression that can examine chains of influence as well as several dependent variables [22]. The PROCESS macro for R (version 4.0.2) was used for all mediation analyses [23]. Mediation models tested the relationship between first impressions, trustworthiness, trust and intention to use. First impressions were split into its components warmth and competence and as these are thought to occur first, entered in turn as independent variable X for each model. Mediators were explored to predict the outcomes trust and intention use. A final model integrated all four concepts of interest in a serial parallel mediation. A. Simple Mediation The effect of warmth on trust was fully mediated via trustworthiness (see Fig. 2). The regression coefficient between warmth and trustworthiness as well as the regression coefficient between trustworthiness and trust were significant. The indirect effect was (.55) * (.73) = .40. The significance of the indirect effect was tested using 5,000 bootstrap samples and the 95% confidence interval ranged from 0.311 to 0.500. This means that 2.5% of the 5,000 bootstrap estimates were smaller than 0.311 and 2.5% were larger than 0.500. As this confidence interval does not include zero, we can reject the null hypothesis that T aT b = 0 and conclude that the indirect effect is statistically significant. There was a significant total effect (c = 0.48, 95% CI 0.385 to 0.581), but no significant direct effect (c ′ = 0.08, 95% CI -0.005 to 0.165). Similarly, results showed that competence has a significant total effect on trust (c = 0.47, p < 0.001). Analyzing the indirect effects reveals that trustworthiness significantly mediates the relationship between competence and trust, ab = 0.45, p < 0.01 (95% CI 0.352 to 0.554). Competence positively affects trustworthiness (a = 0.59, p < 0.001) and trustworthiness, in turn, positively affects trust (b = 0.77, p < 0.001). After accounting for the mediating role of trustworthiness, the direct effect is not significant, indicating that the total effect is fully explained by the mediator (complete mediation). These findings provide some evidence that people who perceive a social robot as competent are more likely to trust it as they tend to also perceive its characteristics as trustworthy. However, people’s ratings of competence do not contribute to trust beyond what is accounted for by trustworthiness. B. Parallel Mediation Two parallel mediator models were designed to test the impact of the mediator trustworthiness in more detail. As trustworthiness is an index made up of the three subscales ability, benevolence and integrity, these constructs were next entered as parallel mediators. The indirect effect of warmth on trust through ability (X → M1 → Y), estimated as a1 ∗ b1 = 0.16 was significant (95% CI 0.089 to 0.241), as was the indirect effect of warmth on trust through benevolence (X → M2 → Y) estimated as a2 ∗ b2 = 0.13 (95% CI 0.049 to 0.239). However, integrity (X → M3 → Y) did not significantly mediate the relationship between warmth and trust (a3b3 = 0.10, 95% CI -0.002 to 0.218). Both the total effect (c = 0.48) and the direct effect (c ′ = 0.09) were statistically significant. A similar parallel mediator model, with the first impression of robot competence as independent variable instead of its warmth, confirmed this trend (see Fig. 3). The indirect effect of competence on trust through ability (X → M1 → Y), estimated as a1 ∗ b1 = 0.18 was significant (95% CI 0.104 to 0.254), as was the indirect effect of competence on trust through benevolence (X → M2 → Y) estimated as a2 ∗ b2 = 0.14 (95% CI 0 0.053 to 0.248). However, even though the estimates for the individual legs a3 and b3 were significant (see Fig. 3), integrity (X → M3 → Y) did not significantly mediate the relationship between competence and trust as the confidence interval included zero (a3b3 = 0.12, 95% CI -0.007 to 0.248). The total effect (c = 0.47) was significant, however, the direct effect (c ′ = 0.03) was not. As integrity did not mediate the relationship between first impressions and trust when entered in parallel with ability and benevolence, a serial model will explore whether integrity in serial with ability and benevolence will provide a significant indirect effect as there is literature indicating this possibility [7]. C. Serial Parallel Mediation Extending the previous two parallel mediator models, a serial model with integrity predicting ability and benevolence predicting trust was run. The direct effect of X on Y was fixed to zero. The indirect effect of warmth on trust through integrity and ability (X → M1 → M2 → Y), estimated as a1 ∗d21 ∗b2 = 0.59∗0.54∗0.50 = 0.16 was significant (95% CI 0.095 to 0.230). The indirect effect of warmth on trust through integrity and benevolence (X → M1 → M3 → Y), estimated as a1 ∗ d31 ∗ b3 = 0.59 ∗ 0.80 ∗ 0.39 = 0.18 was significant (see Fig. 4). The contrast was not significant. A similar model with competence as the independent variable showed comparable results. The indirect effect of competence on trust through integrity and ability (a1 ∗ d21 ∗ b2 = 0.17) as well as the indirect effect through integrity and benevolence (a1 ∗ d31 ∗ b3 = 0.19) were significant. Finally, in order to express the relationship between first impressions, trustworthiness, trust and behavioral intention in one comprehensive model, a serial parallel mediation model was devised using PROCESS model 80 via B matrix specification. The direct effect of X on Y was fixed to zero. The indirect effect of competence on behavioral intention through ability and trust (X → M1 → M4 → Y), estimated as a1 ∗ d41 ∗ b4∗ = 0.41 ∗ 0.43 ∗ 0.61 = 0.11 was significant (95% CI 0.060 to 0.171). Similarly, the indirect effects of competence on behavioral intention through benevolence and trust (X → M2 → M4 → Y), estimated as a2 ∗ d42 ∗ b4 = 0.08 and competence on behavioral intention through integrity and trust (X → M3 → M4 → Y), estimated as a ∗ d43 ∗ b4∗ = 0.08 were significant (see Fig. 5). A serial model with the first impression warmth as independent variable provided similar results. All indirect effects were significant (a1 ∗ d41 ∗ b4 = 0.10, a2 ∗ d42 ∗ b4 = 0.08, a3 ∗ d43 ∗ b4 = 0.08). This paper is available on arxiv under CC 4.0 license. Author: (1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu); (2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu); (3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Author: Author: (1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu); (2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu); (3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Table of Links Abstract Introduction & Related Work Abstract Introduction & Related Work Method Method Analysis & Results Analysis & Results Discussion & Conclusion Discussion & Conclusion References References III. ANALYSIS & RESULTS The research questions were investigated via a series of mediation analyses. Mediation analysis informs the relation between two variables by explaining how they are related [21]. The analysis models how a mediator variable transmits the effect of an independent variable X on a dependent variable Y. Path analysis is an extension of multiple regression that can examine chains of influence as well as several dependent variables [22]. The PROCESS macro for R (version 4.0.2) was used for all mediation analyses [23]. Mediation models tested the relationship between first impressions, trustworthiness, trust and intention to use. First impressions were split into its components warmth and competence and as these are thought to occur first, entered in turn as independent variable X for each model. Mediators were explored to predict the outcomes trust and intention use. A final model integrated all four concepts of interest in a serial parallel mediation. A. Simple Mediation A. Simple Mediation The effect of warmth on trust was fully mediated via trustworthiness (see Fig. 2). The regression coefficient between warmth and trustworthiness as well as the regression coefficient between trustworthiness and trust were significant. The indirect effect was (.55) * (.73) = .40. The significance of the indirect effect was tested using 5,000 bootstrap samples and the 95% confidence interval ranged from 0.311 to 0.500. This means that 2.5% of the 5,000 bootstrap estimates were smaller than 0.311 and 2.5% were larger than 0.500. As this confidence interval does not include zero, we can reject the null hypothesis that T aT b = 0 and conclude that the indirect effect is statistically significant. There was a significant total effect (c = 0.48, 95% CI 0.385 to 0.581), but no significant direct effect (c ′ = 0.08, 95% CI -0.005 to 0.165). Similarly, results showed that competence has a significant total effect on trust (c = 0.47, p < 0.001). Analyzing the indirect effects reveals that trustworthiness significantly mediates the relationship between competence and trust, ab = 0.45, p < 0.01 (95% CI 0.352 to 0.554). Competence positively affects trustworthiness (a = 0.59, p < 0.001) and trustworthiness, in turn, positively affects trust (b = 0.77, p < 0.001). After accounting for the mediating role of trustworthiness, the direct effect is not significant, indicating that the total effect is fully explained by the mediator (complete mediation). These findings provide some evidence that people who perceive a social robot as competent are more likely to trust it as they tend to also perceive its characteristics as trustworthy. However, people’s ratings of competence do not contribute to trust beyond what is accounted for by trustworthiness. B. Parallel Mediation B. Parallel Mediation Two parallel mediator models were designed to test the impact of the mediator trustworthiness in more detail. As trustworthiness is an index made up of the three subscales ability, benevolence and integrity, these constructs were next entered as parallel mediators. The indirect effect of warmth on trust through ability (X → M1 → Y), estimated as a1 ∗ b1 = 0.16 was significant (95% CI 0.089 to 0.241), as was the indirect effect of warmth on trust through benevolence (X → M2 → Y) estimated as a2 ∗ b2 = 0.13 (95% CI 0.049 to 0.239). However, integrity (X → M3 → Y) did not significantly mediate the relationship between warmth and trust (a3b3 = 0.10, 95% CI -0.002 to 0.218). Both the total effect (c = 0.48) and the direct effect (c ′ = 0.09) were statistically significant. A similar parallel mediator model, with the first impression of robot competence as independent variable instead of its warmth, confirmed this trend (see Fig. 3). The indirect effect of competence on trust through ability (X → M1 → Y), estimated as a1 ∗ b1 = 0.18 was significant (95% CI 0.104 to 0.254), as was the indirect effect of competence on trust through benevolence (X → M2 → Y) estimated as a2 ∗ b2 = 0.14 (95% CI 0 0.053 to 0.248). However, even though the estimates for the individual legs a3 and b3 were significant (see Fig. 3), integrity (X → M3 → Y) did not significantly mediate the relationship between competence and trust as the confidence interval included zero (a3b3 = 0.12, 95% CI -0.007 to 0.248). The total effect (c = 0.47) was significant, however, the direct effect (c ′ = 0.03) was not. As integrity did not mediate the relationship between first impressions and trust when entered in parallel with ability and benevolence, a serial model will explore whether integrity in serial with ability and benevolence will provide a significant indirect effect as there is literature indicating this possibility [7]. C. Serial Parallel Mediation C. Serial Parallel Mediation Extending the previous two parallel mediator models, a serial model with integrity predicting ability and benevolence predicting trust was run. The direct effect of X on Y was fixed to zero. The indirect effect of warmth on trust through integrity and ability (X → M1 → M2 → Y), estimated as a1 ∗d21 ∗b2 = 0.59∗0.54∗0.50 = 0.16 was significant (95% CI 0.095 to 0.230). The indirect effect of warmth on trust through integrity and benevolence (X → M1 → M3 → Y), estimated as a1 ∗ d31 ∗ b3 = 0.59 ∗ 0.80 ∗ 0.39 = 0.18 was significant (see Fig. 4). The contrast was not significant. A similar model with competence as the independent variable showed comparable results. The indirect effect of competence on trust through integrity and ability (a1 ∗ d21 ∗ b2 = 0.17) as well as the indirect effect through integrity and benevolence (a1 ∗ d31 ∗ b3 = 0.19) were significant. Finally, in order to express the relationship between first impressions, trustworthiness, trust and behavioral intention in one comprehensive model, a serial parallel mediation model was devised using PROCESS model 80 via B matrix specification. The direct effect of X on Y was fixed to zero. The indirect effect of competence on behavioral intention through ability and trust (X → M1 → M4 → Y), estimated as a1 ∗ d41 ∗ b4∗ = 0.41 ∗ 0.43 ∗ 0.61 = 0.11 was significant (95% CI 0.060 to 0.171). Similarly, the indirect effects of competence on behavioral intention through benevolence and trust (X → M2 → M4 → Y), estimated as a2 ∗ d42 ∗ b4 = 0.08 and competence on behavioral intention through integrity and trust (X → M3 → M4 → Y), estimated as a ∗ d43 ∗ b4∗ = 0.08 were significant (see Fig. 5). A serial model with the first impression warmth as independent variable provided similar results. All indirect effects were significant (a1 ∗ d41 ∗ b4 = 0.10, a2 ∗ d42 ∗ b4 = 0.08, a3 ∗ d43 ∗ b4 = 0.08). This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Trust and Acceptance of Social Robots: Analysis & Results

Author:
(1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu);
(2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu);
(3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Table of Links Abstract Introduction & Related Work Method Analysis & Results Discussion & Conclusion References II. METHOD An online survey was disseminated through Amazon Mechanical Turk. A total of 239 participants (86 females, 153 males) passed the attention check and completed all questionnaires. Empirical estimates of sample sizes needed for 0.8 power in mediation analysis confirm that this sample size is adequate to detect small to medium effects when using Hayes’ PROCESS version 3+ utilizing percentile bootstrap confidence intervals as the default [20]. After consenting to participate in the study, participants were exposed to an image and textual description of the social robot Pepper and filled out demographic questions regarding their age (M = 35.15), gender (86 female, 153 male), education (M = 4.75 years of college/university) and familiarity with robots (M = 3.56 on a 7-point Likert scale) as well as warmth and competence questions, UTAUT assessments and trust and trustworthiness questionnaires. All responses were collected on 7-point Likert scales. The stereotype content model [9] was used to measure first impressions as it has been successfully applied to human perceptions of social robots [11]. The warmth and competence items utilized the statement “As viewed by society, how ... are social robots?”. The warmth dimension contained four items: tolerant, warm, good natured, and sincere (α = 0.74). Competence was comprised of five items: Competent, confident, independent, competitive, and intelligent (α = 0.78). The UTAUT construct behavioral intention [18] consisted of three items (example: “I intend to use the robot”, α = 0.71). We utilized a measure of trust that considered its relationship with trustworthiness and provided assessments of robot ability, benevolence and integrity [7]. Trust was thereby measured directly via 10 questions (α = 0.84), of which one example item was “I would rely on the robot without hesitation”. Trustworthiness was measured via the dimensions of ability (six items, example: “I feel very confident about the robot’s skills”, α = 0.80), benevolence (five items, example: “the needs and desires of others are very important to the robot”, α = 0.82) and integrity (five items, example: “sound principles seem to guide the robot’s behavior”, α = 0.80). An aggregate of these three subscales produced the trustworthiness index (α = 0.85). This paper is available on arxiv under CC 4.0 license. Author: (1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu); (2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu); (3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Author: Author: (1) Katrin Fischer, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: katrinfi@usc.edu); (2) Donggyu Kim, Annenberg School for Communication at the University of Southern California, Los Angeles (Email: donggyuk@usc.edu); (3) Joo-Wha Hong, Marshall School of Business at the University of Southern California, Los Angeles (Email: joowhaho@marshall.usc.edu). Table of Links Abstract Introduction & Related Work Abstract Introduction & Related Work Method Method Analysis & Results Analysis & Results Discussion & Conclusion Discussion & Conclusion References References II. METHOD An online survey was disseminated through Amazon Mechanical Turk. A total of 239 participants (86 females, 153 males) passed the attention check and completed all questionnaires. Empirical estimates of sample sizes needed for 0.8 power in mediation analysis confirm that this sample size is adequate to detect small to medium effects when using Hayes’ PROCESS version 3+ utilizing percentile bootstrap confidence intervals as the default [20]. After consenting to participate in the study, participants were exposed to an image and textual description of the social robot Pepper and filled out demographic questions regarding their age (M = 35.15), gender (86 female, 153 male), education (M = 4.75 years of college/university) and familiarity with robots (M = 3.56 on a 7-point Likert scale) as well as warmth and competence questions, UTAUT assessments and trust and trustworthiness questionnaires. All responses were collected on 7-point Likert scales. The stereotype content model [9] was used to measure first impressions as it has been successfully applied to human perceptions of social robots [11]. The warmth and competence items utilized the statement “As viewed by society, how ... are social robots?”. The warmth dimension contained four items: tolerant, warm, good natured, and sincere (α = 0.74). Competence was comprised of five items: Competent, confident, independent, competitive, and intelligent (α = 0.78). The UTAUT construct behavioral intention [18] consisted of three items (example: “I intend to use the robot”, α = 0.71). We utilized a measure of trust that considered its relationship with trustworthiness and provided assessments of robot ability, benevolence and integrity [7]. Trust was thereby measured directly via 10 questions (α = 0.84), of which one example item was “I would rely on the robot without hesitation”. Trustworthiness was measured via the dimensions of ability (six items, example: “I feel very confident about the robot’s skills”, α = 0.80), benevolence (five items, example: “the needs and desires of others are very important to the robot”, α = 0.82) and integrity (five items, example: “sound principles seem to guide the robot’s behavior”, α = 0.80). An aggregate of these three subscales produced the trustworthiness index (α = 0.85). This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Trust and Acceptance of Social Robots: Method

Liquidity provisioning in Uniswap V3 presents a stochastic optimal control problem with a well-defined utility function to maximize. This article introduces an innovative framework for intelligent liquidity provisioning, utilizing a combination of agent-based modeling and reinforcement learning. Our framework provides a robust and adaptive solution for optimizing liquidity provisioning strategies. The Uniswap V3 model mimics real-world market conditions, while the agent-based model (ABM) creates an environment for simulating agent interactions with Uniswap V3 pools. The reinforcement learning agent, trained using deep deterministic policy gradients (DDPG), learns optimal strategies, showcasing the potential of machine learning in enhancing DeFi participation. This approach aims to improve liquidity providers’ profitability and understanding of CFMM markets. Content Overview Introduction Intelligent liquidity provisioning framework Components of Intelligent Liquidity Provisioning Framework Agent-based simulator Reinforcement Learning Model Limitations Future Work Conclusion Resources References Introduction In my previous article on market making we explored the mechanics and strategies of market making in traditional financial markets. Building upon those insights, this article introduces an innovative framework for intelligent liquidity provisioning in the context of Uniswap V3. As mentioned in our prior research, our goal was to extend our understanding of market dynamics and liquidity management in decentralized finance ( , specifically through the development of the Intelligent Liquidity Provisioning Framework. [Market Making Mechanics and Strategies], DeFi) Decentralized finance (DeFi) has undergone remarkable growth, introducing innovative financial products and services accessible to a global audience. Uniswap V3, at the forefront of this innovation, has revolutionized liquidity provisioning with its concentrated liquidity feature. However, this advancement brings forth complex decision-making challenges for liquidity providers. This article introduces a comprehensive framework designed to address these challenges, offering a simulated environment for studying and optimizing liquidity provisioning strategies. Our framework comprises three key components: the Uniswap V3 model, an agent-based model (ABM), and a reinforcement learning agent. The Uniswap V3 model provides a representation of the pool, enabling the deployment and interaction with tokens and pools. The ABM introduces complexity by simulating agent interactions and market dynamics, creating a rich environment for strategy evaluation. The reinforcement learning agent, operating within this environment, adopts a deep deterministic policy gradient approach to learn and adapt strategies, aiming for optimal performance in liquidity provisioning. This research aims to develop an intelligent liquidity provisioning (ILP) mechanism using reinforcement learning (RL) to autonomously manage and optimize liquidity within the Uniswap V3 environment. The mechanism seeks to maximize the utility function, considering fees earned, impermanent loss, and other metrics based on liquidity providers’ preferences while adapting to the complex dynamics of the CFMM market. Intelligent Liquidity Provisioning Framework In the RL framework, the liquidity provisioning problem is formulated as a Markov Decision Process (MDP). The MDP consists of states, actions, and rewards. States represent the current market conditions, including asset prices, trading volumes, and other relevant variables. States: Actions correspond to the decisions made by the liquidity provider, such as adjusting liquidity allocations, rebalancing portfolios, etc. Actions: Rewards quantify the desirability of the outcomes based on the liquidity provider’s objective function, preferences, and constraints. The rewards can be positive for desirable outcomes (e.g., high returns) and negative for undesirable outcomes (e.g., high risk or underperformance). Rewards: The objective function represents the liquidity provider’s desired outcome, which can be a combination of factors like maximizing returns, minimizing risks, or achieving a specific trade-off between the two. Constraints can include limitations on liquidity allocations, capital utilization, risk tolerance levels, or other restrictions defined by the liquidity provider. Objective Function: RL training is an iterative process where the agent continuously updates its policy based on feedback. The agent learns from its experiences and refines its decision-making over time, gradually converging to more optimal liquidity provisioning strategies. Once the RL agent has been trained, it can be tested and evaluated using historical data or simulated environments to assess its performance against the liquidity provider’s objective function and constraints. The agent’s performance can be measured using metrics like returns, risk measures, or other relevant performance indicators. By applying RL algorithm, the liquidity provisioning mechanism can learn and adapt to changing market conditions, identify optimal liquidity provision strategies, and balance constraints and preferences specified by the liquidity provider. RL enables the mechanism to find solutions that maximize the liquidity provider’s objective function, considering various trade-offs and constraints autonomously and dynamically. Components of Intelligent Liquidity Provisioning Framework The framework comprises three major components: UniswapV3 Model The Uniswap V3 model implemented in Python offers a detailed and functional simulation of the Uniswap V3 protocol, capturing its nuanced mechanics and providing users with a comprehensive toolset for interacting with the protocol. The UniswapV3_Model class handles the deployment of tokens and pools, initializes pools, and provides an interface for pool actions and pool state retrieval. Overview The Uniswap Model serves as the foundation of the Intelligent Liquidity Provisioning Framework, encapsulating the core mechanics of Uniswap V3. It leverages compiled smart contracts from Uniswap’s V3-Core, deployed in a local Ganache environment using brownie, to create a realistic and interactive simulation. Contract Compilation and Deployment The framework integrates with Brownie, a Python-based development and testing framework for smart contracts, to compile and deploy the Uniswap V3 smart contracts. These contracts are then deployed to a local Ganache environment, providing a sandbox for testing and development. This setup ensures that users can interact with the Uniswap environment without the need for real assets or network transactions, fostering a safe and controlled experimentation space. Agent-Based Simulator is used to simulate the Uniswap V3 environment, agent policies are defined to incorporate the dynamics of Uniswap market participants. Different types of agents are used to simulate the dynamic Uniswap environment Tokenspice agent-based simulator Introduction simulates the actions and interactions of individual agents within the Uniswap V3 ecosystem. By modeling the complex behaviors of different participants, the ABM provides a comprehensive interface of Uniswap V3 dynamic environment, enabling the analysis and optimization of liquidity provisioning strategies. Tokenspice Agent-Based Model (ABM) Agent Types and Behaviors The ABM includes various agent types, each representing a specific role within the Uniswap V3 ecosystem. The two main agents are the Liquidity Provider Agent and the Swapper Agent, which interact with the Uniswap pools to provide liquidity and perform token swaps, respectively. The behavior of these agents is dictated by policies defined in the file, ensuring that their actions are aligned with real-world strategies and market conditions. agents_policies.py This agent adds and removes liquidity from the Uniswap pools. It follows a set of policies that dictate its actions based on the current state of the market and the agent’s preferences. Liquidity Provider Agent: The Swapper Agent performs token swaps within the Uniswap pools, taking advantage of price discrepancies and arbitrage opportunities. Its behavior is guided by policies that assess the potential profitability of trades, considering transaction fees and slippage. Swapper Agent: Simulation Configuration and Execution The file is central to the ABM, configuring how agents interact with each other and with the Uniswap pools. It defines the relationships between agents, policies, and the simulation environment. netlist.py The , , and modules provide the foundational elements for running simulations. The SimEngine orchestrates the simulation, managing the flow of time and the execution of agent actions. The SimStateBase maintains the current state of the simulation, storing data on agent holdings, pool states, and other relevant variables. The SimStrategyBase defines the overarching strategies that guide agent behavior throughout the simulation. SimEngine.py SimStateBase.py SimStrategyBase.py Reinforcement Learning Model Introduction The Reinforcement Learning (RL) Agent is a pivotal component of the Intelligent Liquidity Provisioning Framework, designed to interact with the Uniswap V3 ecosystem through Uniswap Model an agent-based model. This section delves into the RL Agent, its environment, and the DDPG (Deep Deterministic Policy Gradient) algorithm used for training. RL Agent Environment The RL Agent operates in a custom environment, , which interfaces with the Uniswap model and the agent-based model to simulate the DeFi market. This environment facilitates the agent’s interaction with Uniswap pools, allowing it to add and remove liquidity, and observe the consequences of its actions. The RL Agent interacts with the Uniswap model and ABM to simulate real-world liquidity provisioning in Uniswap V3. It chooses actions that result in adding or removing liquidity, with policies and simulation configuration defined in the ABM, ensuring realistic interactions. DiscreteSimpleEnv The environment’s state space includes various market indicators such as the current price, liquidity, and fee growth. These parameters are normalized and provided to the agent at each timestep. State Space: The agent’s action space consists of continuous values representing the price bounds for adding liquidity to a Uniswap pool. These actions are translated into interactions with the Uniswap pools, affecting the state of the environment. Action Space: The reward function is crucial for training the RL Agent. It takes into account the fee income, impermanent loss, portfolio value, and potential penalties, providing a scalar reward signal to guide the agent’s learning process. Reward Function: DDPG Agent The DDPG Agent is a model-free, off-policy actor-critic algorithm using deep function approximators. It can handle high-dimensional state spaces and continuous action spaces, making it well-suited for our Uniswap V3 environment. This network is responsible for providing the best-believed action given a state. It has a sigmoid output layer, outputting relative values for and which are then scaled to the desired range in agent env, representing the price bounds for adding liquidity. Actor Network: price_lower price_upper This network evaluates the action value function, estimating the expected return of taking an action in a given state. Critic Network: DDPG employs target networks for both the actor and critic, which are slowly updated to stabilize training. Target Networks: This technique is used to store a replay buffer of past experiences, allowing the agent to learn from a diverse set of samples, breaking correlations in observations, and smoothing out learning. Experience Replay: Interaction with Uniswap Model and ABM The RL Agent leverages the Uniswap model and agent-based model to simulate real-world liquidity provisioning in Uniswap V3. It interacts with the Uniswap pools through the , performing actions that result in adding or removing liquidity. The agent’s policies and the simulation configuration are defined in the ABM component, ensuring a realistic and coherent dynamic environment. DiscreteSimpleEnv The agent is trained over a series of episodes, each representing a different market scenario (different pool). The agent’s performance is evaluated based on its ability to maximize returns while minimizing risks associated with liquidity provisioning. The effectiveness of the Intelligent Liquidity Provisioning Framework is assessed through the evaluation of the reinforcement learning (RL) agent’s performance. Train and Evaluate Agent: To evaluate the RL agent, we set up a specialized evaluation environment, , which extends the base environment, . This environment is tailored for the evaluation of agent policies. Environment Setup: DiscreteSimpleEnvEval DiscreteSimpleEnv In our evaluation setup, we compare the RL agent’s performance against that of a baseline agent. The baseline agent’s actions are determined by a baseline policy that relies on the current state of the liquidity pool. This agent aims to provide a reference point for evaluating the RL agent’s performance. Baseline Agent: Results Training Evaluation Limitations Currently, the framework does not fully capture the real-time synchronization of pools, which can lead to discrepancies in modeling real Uniswap V3 dynamics. Future work should focus on incorporating mechanisms for better pool synchronization, potentially utilizing tick/position data or events to enhance realism. Pools Synchronization: The agent policies employed in the current framework are relatively simple and naive. To achieve more accurate simulations, future iterations should aim to define more comprehensive agent policies. These policies could model various types of Uniswap agents, such as noise traders, informed traders, retail liquidity providers, and institutional liquidity providers. Alternatively, statistical models trained on historical pool data can inform agent policies for more realistic behavior. Naive Agent Policies: The observation space provided to the agents lacks comprehensive information about the state of the pool. To improve decision-making capabilities, future enhancements should include tick and position data, along with engineered features that offer agents a more comprehensive understanding of the pool’s status. Sparse Observation Space: The action space for agents is currently constrained, with fixed liquidity amounts and restricted price range bounds. Expanding the action space to allow for more flexibility in liquidity provision, as well as considering multiple positions per step, can enhance the fidelity of the simulations. Limited Action Space: Future Work Agent Environment: Implement mechanisms to synchronize pools, possibly using tick/position data or events, to create more realistic dynamics in the Uniswap V3 environment. Synced Pools: Actor/Critic Network Architecture, alpha, beta, tau, batch size, steps, episodes, scaling parameters (rewards, actions, observation space) Hyperparameter Tuning: Define more sophisticated analytical policies that accurately model various Uniswap agents or utilize statistical models trained on historical pool data to inform agent behavior. Comprehensive Agent Policies: Enhance the observation space by including tick and position data, and engineer features that provide agents with a comprehensive view of the pool’s state. Informative Observation Space: Develop an improved reward function that accounts for a wider range of factors, leading to more effective agent training. Improved Reward Function: Instead of one position with a fixed budget at each timestep, implement a more comprehensive mechanism in which the agent is allocated a budget once at the start of the simulation and then learns to use this budget optimally in subsequent steps. Multiple Positions: Define more comprehensive baseline policies to evaluate the performance of the RL agent Baseline Policies: Agent Algorithm Further refine and optimize the hyperparameters of the reinforcement learning agent for better training performance. Hyperparameter Tuning: Explore alternative RL agent models, such as Proximal Policy Optimization (PPO) or Soft Actor-Critic (SAC), to determine if they offer advantages in specific scenarios. Experimentation with Other RL Agents: Investigate the application of multi-agent reinforcement learning techniques, which can be beneficial for modeling interactions among multiple liquidity providers and swappers. Multi-Agent RL (MARL): Implement online learning strategies that allow agents to adapt to changing market conditions in real time, providing a more dynamic and adaptive liquidity provisioning solution. Online Learning: Conclusion In the rapidly evolving landscape of decentralized finance (DeFi), liquidity provisioning plays a pivotal role in enabling efficient and secure trading. Uniswap V3, with its innovative concentrated liquidity feature, has pushed the boundaries of what is possible in DeFi liquidity management. However, the complexities of optimizing liquidity provisioning strategies within this dynamic ecosystem require innovative solutions. Our Intelligent Liquidity Provisioning Framework represents a significant step forward in addressing these challenges. By combining agent-based modeling and reinforcement learning, we have created a powerful toolkit for liquidity providers and market participants. This framework offers a robust and adaptive solution for optimizing liquidity provisioning strategies, with a focus on maximizing utility functions that encompass fees earned, impermanent loss mitigation, and other metrics tailored to individual preferences. Resources Github: https://github.com/idrees535/Intelligent-Liquidity-Provisioning-Framework-V1 References https://kth.diva-portal.org/smash/get/diva2:1695877/FULLTEXT01.pdf https://arxiv.org/pdf/2305.15821.pdf https://github.com/KodAgge/Reinforcement-Learning-for-Market-Making/tree/main https://arxiv.org/ftp/arxiv/papers/2211/2211.01346.pdf https://arxiv.org/pdf/2004.06985.pdf https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9682687 https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0277042 https://deliverypdf.ssrn.com/delivery.php?ID=104119098102026014120072084014107007042068069003049020126088025087121115103007084028042013055035009000054122074096068089064070102052026003014069082076098016080066026088066039027093020006122067093104092065070020126069068106118079127088008098077106031120&EXT=pdf&INDEX=TRUE https://medium.com/blockapex/market-making-mechanics-and-strategies-4daf2122121c https://www.gauntlet.xyz/resources/uniswap-user-cohort-analysis https://gov.uniswap.org/t/uniswap-incentive-design-analysis/21662 https://arxiv.org/pdf/2108.07806.pdf https://www.researchgate.net/publication/341848292_Market_makers_activity_behavioural_and_agent_based_approach https://fruct.org/publications/volume-29/fruct29/files/Struc.pdf https://www.arxiv-vanity.com/papers/1911.03380/ https://insights.glassnode.com/the-week-onchain-week-31-2023/ Also published . here

A Detailed Framework for Intelligent Liquidity Provisioning in Uniswap V3 

Uniswap V3-এ বুদ্ধিমান তারল্য বিধানের জন্য একটি বিস্তারিত কাঠামো

Ein detailliertes Framework für die intelligente Liquiditätsbereitstellung in Uniswap V3

Un marco detallado para el aprovisionamiento inteligente de liquidez en Uniswap V3

Un cadre détaillé pour l'approvisionnement intelligent en liquidités dans Uniswap V3

Uniswap V3 में बुद्धिमान तरलता प्रावधान के लिए एक विस्तृत रूपरेखा

Uniswap V3 におけるインテリジェントな流動性プロビジョニングの詳細なフレームワーク

Uniswap V3의 지능형 유동성 프로비저닝을 위한 세부 프레임워크

Uma estrutura detalhada para provisionamento inteligente de liquidez no Uniswap V3

Подробная структура интеллектуального предоставления ликвидности в Uniswap V3

Uniswap V3'te Akıllı Likidite Tedariği için Ayrıntılı Bir Çerçeve

Khung chi tiết để cung cấp thanh khoản thông minh trong Uniswap V3

Uniswap V3 智能流动性配置的详细框架

In my , I have shown a way to unify the implementation of the most well-known graph-traversal algorithms. Now, let's make it more visually appealing and look into the performance differences. last post The story behind A few years ago, Yandex organized a contest called with an enticing prize: a ticket to a . The contest resembled a game, with participants tasked with finding optimal routes on a map and optimizing delivery using robotic couriers. Robots Couriers closed self-driving conference for professionals As I delved into the topic, I discovered that despite route finding being a solved problem, it continued to interest the professional game development community. Between 2010 and 2020, engineers , particularly beneficial for AAA games with massive maps. Reading on these optimizations was an exciting experience. made significant optimizations to the A* algorithm articles and research papers Furthermore, the contest requirements were designed to enable easy assessment of program outputs by the contest’s testing system. As a result, there was little emphasis on visualization. I found exploring this field intriguing and developing a small application that uses well-known graph algorithms to find routes on a grid map. To visualize my findings, I employed the SFML graphics library. Goal This project builds upon one of , where I demonstrated that four well-known path-finding algorithms (BFS, DFS, Dijkstra's, and A*) are not fundamentally different and can be implemented in a universal way. However, it was challenging to showcase significant performance differences among these algorithms in that project. my previous endeavors In this article, I aim to use improved test data and design something visually exciting. While the Yandex Contest task mentioned earlier aligns well with my goals, I will not solve their specific problem here since it heavily relies on their test system, which is currently unavailable. Instead, I will extract general ideas for input parameters from that contest and create my own implementation. Imaginary world Imagine a technically advanced and innovative city where the future has arrived long ago. In this city, the majority of orders are delivered by courier robots, and it has become a rarity for a person to deliver an order from a cafe. In this task, we invite you to participate in finding optimal routes to deliver orders efficiently. Let's envision the city as an N × N map. For simplicity, we assume that each robot occupies exactly one cell, and each cell can either be passable or not for the robots. In one step, a robot can move in any of the four cardinal directions (up, down, left, or right) if the target cell is free. And I'm of the original task: ignoring the rest At the beginning of the test, you need to output the number of robots you want to use to deliver orders and their initial coordinates. The construction of each robot will cost Costc rubles. Next, T iterations of the simulation will be performed. One iteration represents one virtual minute and consists of 60 seconds. At each iteration, your program will be given the number of new orders, and in response, the program should tell you what actions each robot performs (60 actions per robot). For each successfully delivered order, you will receive max(0, MaxTips - DeliveryTime) dollars in tips, where MaxTips is the maximum number of tips for one order, and DeliveryTime is the time from the moment the order appeared to its delivery in seconds. The total number of points that you earn in one test is calculated by the formula TotalTips - R × Costc, where TotalTips is the total number of tips earned, R is the number of robots used, Costc is the cost of building one robot. The Costc and MaxTips values are set in each test. If you earned less tips than you spent on making robots, your total points will be 0. You will also receive 0 points for the test if you perform any incorrect action. Input The program uses standard input to read the parameters. This approach allows us to specify test data of various complexities using input files. The first line of input contains three natural numbers: N (the size of the city map), MaxTips (the maximum number of tips per order), and Costc (the cost of building one robot). I ignored both MaxTips and Costc parameters for my first implementation and maybe will consider that in the future. Following that, each of the next N lines contains N characters representing the city map. Each string can consist of two types of characters: '#' - indicates a cell occupied by an obstacle. '.' - indicates a free space. Next, you will be provided with two natural numbers: T and D (T ≤ 100,000, D ≤ 10,000,000). T represents the number of interaction iterations, and D represents the total number of orders. Output Your task is to visualize the map and the optimal routes using the SFML graphics library. Modelling the maps I'm fond of maps represented as a grid of cells. Thus, I prefer to render all the results and map them as a grid on cell by cell basis. There is also the option to execute path search right on the grid without using any additional data structure (and I have implemented this as well for learning purposes: see in code). But because of a grid, it is easy to represent a map as a graph in one way or another. I prefer to use an adjacency list of cells for most of the algorithms like BFS, Dijkstra's, and A-Star. For algorithms like Bellman-Ford, it may make sense to use an Edges List instead of an Adjacency List. That's why if you explore the codebase, then you will find all of it, and they all are working examples. To split the logic and responsibility, I have a entity that is responsible for executing path finding according to the orders and tasks configuration that is specified via the file and related map files. Navigator App Config looks like this: App Config {
    "font": "../../data/arial.ttf",
    "map": "../../data/maps/test_29_yandex_weighten_real_map",
    "shadow": false,
    "map_": "../../data/maps/test_08_low_res_simple_map",
    "map__": "../../data/maps/test_10",
    "map___": "../../data/maps/test_07_partially_blocked_map",
    ... Note that "map_” "map__" etc. are not really configuration properties. They are ignored during the application run. Since there is no way to comment on the part of the JSON file, I use underlining in the property name so it can stay in the config file but not be used. looks like this: The map file 25 50 150
#########################
#########################
#########################
###.......#####.......###
###.......#####.......###
###.......#####.......###
###...................###
###.......#####.......###
###.......#####.......###
###...................###
######.###########.######
######.###########.######
######.###########.######
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
######.###########.######
#########################
#########################
#########################
#########################
2 4
2
6 6 4 20 This is one of the simplest examples that contain either blocked or not blocked cells. I have prepared a lot of various examples of input parameters and test data. Starting from very small parts that let you debug and learn the code, finishing with a huge piece of map (from the real existing city) that allows us to measure the performance of a Graph algorithm. How do we draw such maps? When a map contains only cells with binary state (either blocked or non-blocked), this basically means that any edge of a graph either exists or not. To find a path in the graph, we have to represent it efficiently. Like in my previous post, I have used an with the relationship as Vector[NodeId]->points to->Vector[Neighbour Nodes]: adjacency list typedef std::vector<std::vector<std::shared_ptr<Cell>>> Graph; When we exploring grids it's not really necessary to use graphs at all. We are capable to traverse grid using BFS/DFS algorithms cell by cell without thinking about edges. See method for example. _GetPathByBFSOnGrid First, the initialization code reads the file and converts it into row by row and column by column: the grid bool RectangularMap::LoadMap(const std::string& filepath, bool shadow)
{
...
  // Fill the grid.
  _verticesNumber = 0;
  for (int row = 0; row < _height; row++)
  {
    ...
    for (int col = 0; col < _width; col++)
    {
      int x = col;
      int y = row;
      if (line[col] == BLOCK_CELL)
      {
        // Create a shared pointer here to safely pass pointers between the classes.
        _grid[row][col] = std::make_shared<Cell>(x, y, line[col], blockColor, shadow, _scaleFactor);
      }
      else
      {
        ...
      }
    }
  }

  // Make a graph
  InitialiseGraph();
...
} Then, it creates an actual graph as : an adjacency list void RectangularMap::InitialiseGraph()
{
  MapBase::InitialiseGraph();
  ...
  unordered_set<int> visited;

  for (int rr = 0; rr < _grid.size(); rr++)
  {
    for (int cc = 0; cc < _grid[rr].size(); cc++)
    {
      if (_grid[rr][cc]->GetId() > -1)
      {
        for (int i = 0; i < 4; i++)
        {
          int r = rr + dr[i];
          int c = cc + dc[i];

          if (r >= 0 && c >= 0 && r < _width && c < _height &&
              _grid[r][c]->GetId() > -1)
          {
            if (_isNegativeWeighten)
            {
              ...
            }
            else
            {
              _adjacencyList[_grid[rr][cc]->GetId()].push_back(_grid[r][c]);
            }
          }
        }
      }
    }
  }
} Grid representation is useful to draw on the screen using the SFML library. We can draw (this is exactly what I do for small maps): by creating a geometric object ...
for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    _grid[j][i]->Draw(_window, _scaleFactor);
  }
}
...
sf::RectangleShape tile;
tile.setSize(sf::Vector2f(_cellSize - 5, _cellSize - 5));
tile.setPosition(sf::Vector2f(_x * _cellSize, _y * _cellSize));
tile.setFillColor(_color);
window.draw(tile); Or we can do it for larger maps: efficiently pixel by pixel sf::Uint8* pixels = new sf::Uint8[_width * _height * 4];

for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    int index = (_grid[j][i]->GetY() * _width + _grid[j][i]->GetX());

    sf::Color color = _grid[j][i]->GetColor();
    pixels[index * 4] = color.r;
    pixels[index * 4 + 1] = color.g;
    pixels[index * 4 + 2] = color.b;
    pixels[index * 4 + 3] = color.a;
  }
}

sf::Texture texture;
texture.create(_width, _height);
texture.update(pixels);
sf::Sprite sprite;
sprite.setTexture(texture);
sprite.setScale(cellSize, cellSize);
_window.draw(sprite); Finally, let's see what a map defined by file would look like. Originally, the file defined this: test_25_xmax ..............C.................
..............#.................
.............###................
............#####...............
...........#######..............
..........##1###2##.............
.........###########............
........##3######4###...........
.......###############..........
......#################.........
.....###################........
....#####################.......
.............###................
.............###................
.............###................ And a map renderred with SFML looks like this: Because I wanted all of that to be controlled by the user with the keyboard, I left all the user-behavior logic in the . I like to call it “Controller” logic. main.cpp SFML library makes it very easy to handle keyboard events: while (window.isOpen())
{
  Event event;
  while (window.pollEvent(event))
  {
    if (event.type == Event::Closed)
      window.close();

    if (event.type == Event::KeyPressed && event.key.code == Keyboard::Space)
    {
      ... Do what you need here
    }
  }
} The main idea is for user triggers (press of a SPACE button) to read the map file and rendering the map, and then by a second trigger (second press of a SPACE button) to load the routing task and calculate the shortest path between two points on the map: ...
if (navigator->IsReady())
{
  navigator->Navigate(); // Finding route between two points
}
else
{
  if (map->IsReady()) // Second SPACE press runs the routing
  {
    skipReRendering = true;
    if (navigator->LoadTasks(filepath))
    {
      navigator->SetMap(map);
    }
  }
  else // Load and draw map
  {
    drawLoading(window, font);
    if (!map->LoadMap(filepath, shadowed))
    {
      return 0;
    }
    drawProcessing(window, font);
  }
}
... We need to go deeper I wanted to play with more Graph algorithms, and they all have their limitations, so I decided to implement multi-color maps that can be represented by multi-weighted graphs. Every cell is colored, and the color means that the edge not only exists but also applies some weight (or fee, or fine, you name it). So, the edge might be blocked, half blocked, not blocked, ... you got the idea. Thus, I have implemented multi-color maps that look more joyful and look like a game-ready (example from file ): test_31_multi_weight_graph_map Some of the configuration files contain more complex maps from really existing cities, like : test_29_yandex_weighten_real_map As a challenge, now we should handle maps with very flexible configuration. essentially contains a lot of logic inside, including all the graph algorithms and even more than needed (because I like to play with things, even if it's not particularly useful for now). RectangularMap.cpp I have implemented , , , algorithms, and a number of additional "utility" algorithms like Topological Sort, Single Source Path, that are not useful for the current application state (because they work on Directly Acyclic Graphs, which are not type of Graphs I currently use), but I have some ideas to use it in future improvements. BFS#Line 598 Dijkstra#Line 299 A-Star#Line 356 Bellman-Ford#Line 428 I didn't polish all the code and didn't get it ideal enough, but it allows me (and, I hope, will allow you) to play with the code and compare performance metrics. Sorry about some commented lines here and there, maybe some dirty code...it's all way of learning :). To grasp an idea of what's inside, I recommend you review the . RectangularMap.h There are also some fun features, like a Focus feature that allows one to render only a particular part of a map. It changes focus by re-rendering the necessary part using the when the user presses the PgDown or PgUp buttons. It is pretty easy to improve this feature and implement "Zoom" functionality. Take it as a homework, if you like it. Observer pattern Focus feature with map file in work: test_29_yandex_weighten_real_map Classes diagram looks like this: Run and play I believe the most joyful part is just running this little application is playing with variations of its configuration and algorithms. You can do a lot of experiments by using various map files as input parameters with different test data as well as change the logic in the code. After starting, you need to press SPACE an application will render a map according to the configuration file, and it makes a lot of sense to start exploring from the simplest test cases and moving forward to the most complex ones. Pressing SPACE one more time executes the routing algorithms and finds the path between the start and the nearest order. BTW, It's not yet done, but it is easy to implement reading all the rest of the orders available in map configuration files and execute pathfinding to all of them. Here is the route found on the map defined by file : test_18_yandex_super_high_res It is also capable of finding routes in the maps that simulate existing cities, like : test_29_yandex_weighten_real_map Finding efficient paths between two coordinates becomes challenging for algorithms like BFS but can be easily done by A-star. Based on the cells found in the map configuration files, the application will treat the map as a weighted or non-weighted graph and will select the right algorithm for it (and you can easily change this as well). It's easy to see the difference between BFS and A-Star performance: Final words With this, I want to leave you alone and let you play with these code examples. I hope you will find it fascinating and will learn a lot from it. Stay tuned! Links JPS+: Over 100x Faster than A* by Steve Rabin A* Optimizations and Improvements by Lucho Suaya https://hackernoon.com/bfs-dfs-dijkstra-and-a-star-are-basically-the-same-algorithm-ill-show-you-why My blog https://antonyarkov.substack.com/ Also published . here

Graph Traversal Algorithms: Visualizing Performance Variations in Route Finding Algorithms

How I Cloned a Simple VSCode Using Tauri and ReactJS

Today you will learn how to build your own clone of the 2048 game in React. What makes this article unique is that we will focus on creating delightful animations. Aside from React, we will use TypeScript and we'll make some CSS transitions using LESS. We are only going to use modern React interfaces such as hooks and the Context API. This article contains a few external resources such as: 2048 Game (GitHub Pages) Animation Examples for 2048 (GitHub Pages) Source Code (GitHub) ...and a YouTube video. It took me more than a month to prepare this tutorial, so it would mean the world to me if you watch it, smash the like button, and subscribe to my channel. Thank you! 2048 Game Rules In this game, the player must combine tiles containing the same numbers until they reach the number 2048. The tiles can contain only integer values starting from 2, and that are a power of two, like 2, 4, 8, 16, 32, and so on. Ideally, the player should reach the 2048 tile within the smallest number of steps. The board has dimension of 4 x 4 tiles, so that it can fit up to 16 tiles. If the board is full, and there is no possible move to make like merging tiles together - the game is over. While creating this tutorial I took shortcuts to focus on the game mechanics and animations. What did I get rid of? In our example, the game always creates a new tile with the number 2. But in the proper version it should generate a random number (either 2 or 4 - to make it harder to play). Also, we will not handle wins and loses. You can play after you complete the number 2048, and nothing happens when the board is unsolvable - you need to click the reset button. I skipped the scoring. If you want you can implement those missing features on your own. Just fork my repository and implement it on your own setup. The Project Structure The application contains the following elements: Board (component) – responsible for rendering tiles. It exposes one hook called . useBoard Grid (component) – renders 4x4 grid. Tile (component) – responsible for all animations related to the tile, and rendering the tile itself. Game (component) – combines all elements above together. It includes a hook which is responsible for enforcing the game rules and constrains. useGame How to Build the Tile Component We want to invest more time in animations, so I will start the story from the Tile component. In the end, this component is responsible for all animations in the game. There are only two fairly simple animations in 2048 – tile highlighting, and sliding it across the board. We can handle those animations with CSS transitions by declaring the following styles: {
  // ... : transform; : ; : (1);
} .tile transition-property transition-duration 100ms transform scale At the current moment I defined only one transition that will highlight the tile when it is created or merged. We will leave it like that for now. Let's consider how the Tile meta data is supposed to look, so we can easily use it. I decided to call it since we don't want to have the name conflict with other entities such as the Tile component: TileMeta TileMeta = {
  id: ;
  position: [ , ];
  value: ;
  mergeWith?: ;
}; type number number number number number – the unique identifier of the tile. It is important so that the React DOM doesn't re-render all tiles from scratch on every change. Otherwise, we would see all tiles highlighted on every action of the player. id – the position of the tile on the board. It is an array with two elements, the and coordinate (the possible values are - in both cases). position x y 0 3 – the tile value. Only the power of two, starting from . value 2 – (optional) the id of the tile which is going to absorb the current tile. If it is present, the tile should be merged into another tile, and disappear. mergeWith How to Create and Merge Tiles We want to somehow highlight that the tile changed after the player's action. I think the best way would be changing the tile's scale to indicate that a new tile has been created or one has been changed. Tile = { [scale, setScale] = useState( ); prevValue = usePrevProps< >(value); isNew = prevCoords === ; hasChanged = prevValue !== value; shallAnimate = isNew || hasChanged;

  useEffect( { (shallAnimate) {
      setScale( );
      setTimeout( setScale( ), );
    }
  }, [shallAnimate, scale]); style = {
    transform: ,
  }; (
    <div className={ } style={style}>
      {value}
    < export const ( ) => { value, position }: Props const 1 const number const undefined const const => () if 1.1 => () 1 100 const `scale( )` ${scale} return `tile tile- ` ${value} /div>
  );
}; To trigger the animation, we need to consider two cases: a new tile – the previous value will be . null the tile changed the value – the previous value will be different than the current one. And the result is the following: You might've noticed that I'm using a custom hook called . It helps to track the previous values of the component properties (props). usePrevProps I could use references to retrieve the previous values but it would clutter up my component. I decided to extract it into a standalone hook, so the code is readable, and I can use this hook in other places. If you want to use it in your project, just copy this snippet: { useEffect, useRef } ; usePrevProps = <K = > { ref = useRef<K>();

  useEffect( {
    ref.current = value;
  }); ref.current;
}; import from "react" /**
 * `usePrevProps` stores the previous value of the prop.
 *
 * @param {K} value
 * @returns {K | undefined}
 */ export const any ( ) => value: K const => () return How to Slide Tiles Across the Board The game will look janky without animated sliding of tiles across the board. We can easily create this animation by using CSS transitions. The most convenient will be to use properties responsible for positioning, such as and . So we need to modify our CSS styles to look like this: left top { : absolute;
  // ... : left, top, transform; : , , ; : (1);
} .tile position transition-property transition-duration 250ms 250ms 100ms transform scale Once we've declared the styles, we can implement the logic responsible for changing a tile's position on the board. Tile = { [boardWidthInPixels, tileCount] = useBoard(); useEffect( { }, [shallAnimate, scale]); positionToPixels = { (position / tileCount) * (boardWidthInPixels );
  }; style = {
    top: positionToPixels(position[ ]),
    left: positionToPixels(position[ ]),
    transform: ,
    zIndex,
  }; }; export const ( ) => { value, position, zIndex }: Props const // ... => () // ... const ( ) => position: number return as number const 1 0 `scale( )` ${scale} // ... As you can see, the equation in the function needs to know the position of the tile, the total amount of tiles per row and column, and the total board length in pixels (width or height – same, it is a square). The calculated value is passed down to the HTML element as an inline style. positionToPixels Wait a minute... but what about the hook and property? useBoard zIndex allows us to access the properties of the board within the children components without passing them down. The Tile component needs to know the width and total count of tiles to find the right spot on the board. Thanks to React Context API we can share properties across multiple layers of components without polluting their properties (props). useBoard is a CSS property that defines the order of tile on the stack. In our case it is the id of the tile. As you can see on the gif below, the tile can be stacked on each other, so the enabled us to specify which one will be on top. zIndex zIndex How to Build the Board Another important part of the game is the Board. The component is responsible for rendering the grid and tiles. Board It seems like the Board has duplicated business logic with Tile component, but there is a small difference. The Board holds information about its size (width and height), and number of columns and rows. It's the opposite of the Tile which only knows its own position. Props = {
  tiles: TileMeta[];
  tileCountPerRow: ;
}; Board = { containerWidth = tileTotalWidth * tileCountPerRow; boardWidth = containerWidth + boardMargin; tileList = tiles.map( (
    <Tile key={ } {...restProps} zIndex={id} />
  )); (
    <div className= style={{ width: boardWidth }}>
      <BoardProvider containerWidth={containerWidth} tileCountPerRow={tileCountPerRow}>
        <div className= >{tileList}< >
      < div>
  );
}; type number const ( ) => { tiles, tileCountPerRow = 4 }: Props const const const ( ) => { id, ...restProps } `tile- ` ${id} return "board" "tile-container" /div>
        <Grid / /BoardProvider>
    </ The Board component uses the to distribute the width of the tile container and amount of tiles per row and column to all tiles and the grid component. BoardProvider BoardContext = React.createContext({
  containerWidth: ,
  tileCountPerRow: ,
}); Props = {
  containerWidth: ;
  tileCountPerRow: ;
  children: ;
}; BoardProvider = ({
  children,
  containerWidth = ,
  tileCountPerRow = ,
}: Props) => { (
    <BoardContext.Provider value={{ containerWidth, tileCountPerRow }}>
      {children}
    < const 0 4 type number number any const 0 4 return /BoardContext.Provider>
  );
}; The uses the React Context API to propagate properties down to every child. If any component needs to use any value available on the provider it can retrieve it by calling the hook. BoardProvider useBoard I am going to skip this topic since I spoke more about it in my . If you wish to learn more about them you can watch it. video on Feature Toggles in React useBoard = { { containerWidth, tileCount } = useContext(BoardContext); [containerWidth, tileCount] [ , ];
}; const => () const return as number number How to Build the Game Component Now we can specify the rules of game, and expose the interface to play the game. I am going to start with the navigation since it will help you understand why the game logic is implemented that way. { useThrottledCallback } ; Game = { [tiles, moveLeft, moveRight, moveUp, moveDown] = useGame(); handleKeyDown = { e.preventDefault(); (e.code) { :
        moveLeft(); ; :
        moveRight(); ; :
        moveUp(); ; :
        moveDown(); ;
    }
  }; throttledHandleKeyDown = useThrottledCallback(
    handleKeyDown,
    animationDuration,
    { leading: , trailing: }
  );

  useEffect( { .addEventListener( , throttledHandleKeyDown); { .removeEventListener( , throttledHandleKeyDown);
    };
  }, [throttledHandleKeyDown]); <Board tiles={tiles} tileCountPerRow={ } />;
}; import from "use-debounce" const => () const const ( ) => e: KeyboardEvent // disables page scrolling with keyboard arrows switch case "ArrowLeft" break case "ArrowRight" break case "ArrowUp" break case "ArrowDown" break // protects the reducer from being flooded with events. const true false => () window "keydown" return => () window "keydown" return 4 As you can see, the game logic will be handled by the hook that exposes the following properties and methods: useGame – an array of tiles available on the board. It uses the TileMeta type described above. tiles – a function that slides all tiles to the left side of the board. moveLeft – a function that slides all tiles to the right side of the board. moveRight – a function that slides all tiles to the top of the board. moveUp – a function that slides all tiles to the bottom of the board. moveDown We use the callback to prevent players from flooding the game with tons of moves at the same time. Basically, the player needs to wait until the animation is complete before they can trigger another move. throttledHandleKeyDown This mechanism is called throttling. I decided to use the hook from the package. useThrottledCallback use-debounce How to Use the useGame Hook I mentioned above that the Game component will be handling the rules of the game as well. We are going to extract the game logic into a hook rather than writing it directly onto the component (since we don't want to clutter the code). The hook is based on the hook which is a built-in hook within React. I will start by defining the shape of the reducer's state. useGame useReducer TileMap = { 
  [id: ]: TileMeta;
} State = {
  tiles: TileMap;
  inMotion: ;
  hasChanged: ;
  byIds: [];
}; type number type boolean boolean number The state contains the following fields: – a hash table responsible for storing tiles. The hash table makes it easy to lookup entries by their keys, so it is a perfect match for us since we want to find tiles by their ids. tiles – an array containing all ids in the expected order (that is, ascending). We must keep the right order of tiles, so React doesn't re-render the whole board every time we change the state. byIds – keeps track of tile changes. If nothing has changed the new tile will not be generated. hasChange – determines if tiles are still moving. If they are, the new tile will not be generated until the motion is completed. inMotion Actions requires to specify the actions that are supported by this reducer. useReducer Action =
  | { : ; tile: TileMeta }
  | { : ; tile: TileMeta }
  | { : ; source: TileMeta; destination: TileMeta }
  | { : }
  | { : }; type type "CREATE_TILE" type "UPDATE_TILE" type "MERGE_TILE" type "START_MOVE" type "END_MOVE" What are those actions responsible for? – creates a new tile, and appends it into the tiles hash table. It changes the flag to since this action is always triggered when a new tile is appended to the board. CREATE_TILE hasChange false – updates an existing tile. It doesn't modify the id which is important to keep the animations working. We will use it to reposition the tile and change its value (during merges). Also, it changes the flag to . UPDATE_TILE hasChange true – merges a source tile into a destination tile. After this operation, the destination tile will change its value (the value of the source tile will be added into it). And it will remove the source tile from the tiles table and array. MERGE_TILE byIds – tells the reducer it should expect multiple actions, so it must wait until all animations are complete before it will be able to generate a new tile. START_MOVE – tells the reducer all actions were completed, and it can safely create a new tile. END_MOVE If you don't understand why we defined those actions, don't worry – now we are going to implement a hook which will hopefully shed some light on it. How to Implement the Hook Let's look into the function which is responsible for a player's moves. We will focus on the move left only since the other ones are almost the same. moveLeftFactory = { retrieveTileIdsByRow = { tileMap = retrieveTileMap(); tileIdsInRow = [
        tileMap[tileIndex * tileCount + ],
        tileMap[tileIndex * tileCount + ],
        tileMap[tileIndex * tileCount + ],
        tileMap[tileIndex * tileCount + ],
      ]; nonEmptyTiles = tileIdsInRow.filter( id !== ); nonEmptyTiles;
    }; calculateFirstFreeIndex = (
      tileIndex: ,
      tileInRowIndex: ,
      mergedCount: ,
      _: ) => { tileIndex * tileCount + tileInRowIndex - mergedCount;
    }; move.bind( , retrieveTileIdsByRow, calculateFirstFreeIndex);
  }; moveLeft = moveLeftFactory(); const => () const ( ) => rowIndex: number const const 0 1 2 3 const ( ) => id 0 return const number number number number return return this const As you can see, I decided to bind two callbacks to the function. This technique is called the inversion of control – so the consumer of the function will be able to inject their own values into the executed function. move If you don't know how works you should learn about it because it is a very common question on job interviews. bind The first callback called is responsible of finding all non-empty tiles available in a row (for horizontal moves – left or right). If the player does the vertical (up or down) moves we will look for all tiles in a column. retrieveTileIdsByRow The second callback called finds the closest position to the board's border based on the given parameters such as tile index, index of the tile in row or column, number of merged tiles, and the maximum possible index. calculateFirstFreeIndex Now we are going to look into the business logic of the function. I've explained the code of this function in the comments. The algorithm might be a bit complex, and I believe It will be easier to understand it if I document the code line by line: move RetrieveTileIdsByRowOrColumnCallback = []; CalculateTileIndex = (
    tileIndex: ,
    tileInRowIndex: ,
    mergedCount: ,
    maxIndexInRow: ) => ; move = (
    retrieveTileIdsByRowOrColumn: RetrieveTileIdsByRowOrColumnCallback,
    calculateFirstFreeIndex: CalculateTileIndex
  ) => { dispatch({ : }); maxIndex = tileCount - ; ( tileIndex = ; tileIndex < tileCount; tileIndex += ) { availableTileIds = retrieveTileIdsByRowOrColumn(tileIndex); previousTile: TileMeta | ; mergedTilesCount = ; availableTileIds.forEach( { currentTile = tiles[tileId]; (
          previousTile !== &&
          previousTile.value === currentTile.value
        ) { tile = {
            ...currentTile,
            position: previousTile.position,
            mergeWith: previousTile.id,
          } TileMeta; throttledMergeTile(tile, previousTile); previousTile = ; mergedTilesCount += ; updateTile(tile);
        } tile = {
          ...currentTile,
          position: indexToPosition(
            calculateFirstFreeIndex(
              tileIndex,
              nonEmptyTileIndex,
              mergedTilesCount,
              maxIndex
            )
          ),
        } TileMeta; previousTile = tile; (didTileMove(currentTile, tile)) { updateTile(tile);
        }
      });
    } setTimeout( dispatch({ : }), animationDuration);
  }; type ( ) => tileIndex: number number type number number number number number const // new tiles cannot be created during motion. type "START_MOVE" const 1 // iterates through every row or column (depends on move kind - vertical or horizontal). for let 0 1 // retrieves tiles in the row or column. const // previousTile is used to determine if tile can be merged with the current tile. let undefined // mergeCount helps to fill gaps created by tile merges - two tiles become one. let 0 // interate through available tiles. ( ) => tileId, nonEmptyTileIndex const // if previous tile has the same value as the current one they should be merged together. if undefined const as // delays the merge by 250ms, so the sliding animation can be completed. // previous tile must be cleared as a single tile can be merged only once per move. undefined // increment the merged counter to correct position for the consecutive tiles to get rid of gaps 1 return // else - previous and current tiles are different - move the tile to the first free space. const as // previous tile becomes the current tile to check if the next tile can be merged with this one. // only if tile has changed its position will it be updated if return // wait until the end of all animations. => () type "END_MOVE" The complete code of this hook has more than 400 lines of code, so instead of pasting it here I decided to keep it on GitHub – so please . review the complete code there Summary I hope you enjoyed my tutorial. This time I decided to focus on the essence of the topic rather than building basic React and CSS, so I skipped those basic parts. I believe it makes this article easier to digest. Any feedback or questions? ! Shout at me on twitter If you found this article helpful please share it, so more developers can learn from it. Occasionally I , and it would be great if you subscribe to my channel, hit the like button, and drop a comment under your favourite video. publish videos on my YouTube channel Stay tuned! This article was first published at: https://www.freecodecamp.org/news/how-to-make-2048-game-in-react/

How I Remade 2048 Using React

Originally conceived by Elon Musk in 2013, the Hyperloop has been touted as the fastest way to cross the surface of the Earth. Possibly one of the greatest leaps in transportation for generations, the concept promises to slash journey times between cities from several hours to a matter of minutes. On track to revolutionise our world, when can we expect the Hyperloop to become a reality and is it too good to be true? Here's an episode of The Detechtor Podcast where I discuss the Hyperloop: The History of Hyperloop The technology used in the Hyperloop has been around for a while, in fact, the idea of travelling through evacuated tubes dates back more than a century, although the atmospheric railway was never a commercial success. Musk first mentioned that he was thinking about a concept for a "fifth mode of transport", officially calling it the , in July 2012 at a PandoDaily event in Santa Monica, California. Hyperloop He envisions the more advanced versions will be able to go at hypersonic speed and likened the Hyperloop to a "cross between a Concorde, a railgun, and an air hockey table". Until August of the following year, Tesla and SpaceX worked on the conceptual modelling of Hyperloop with an early system design published in the Tesla and SpaceX blogs which describes one potential design, function, pathway, and cost of a hyperloop system. Since 2015, the yearly Hyperloop Pod Competition sponsored by SpaceX allowed student and non-student teams participate to design and for some, build a subscale prototype transport vehicle in order to demonstrate the technical feasibility of various aspects of the Hyperloop concept. The 2020 competition announced in 2019 was planned for a 10 times longer track of 10 km however because of the virus, Elon Musk announced in July 2020 that the competition will not take place and that the track has not yet been finished. The players in the race for the first Hyperloop When Elon Musk introduced his Hyperloop concept in 2012, it was deliberately an open-source project, allowing students, companies and teams around the world to share ideas, technology and innovate together. Since then, several companies and student teams have made huge leaps towards the Hyperloop becoming a reality, so here are some of the biggest players in the race to building the first Hyperloop system: , probably one of the biggest companies working on a Hyperloop system was incorporated in 2014 and has built a team of 280 people including engineers, technicians, welders, and machinists. In May 2017, Hyperloop One performed its first full-scale Hyperloop test, becoming the first company in the world to test a full-scale Hyperloop. The system-wide test integrated Hyperloop components including vacuum, propulsion, levitation, sledge, control systems, tube, and structures. Not long after, the company revealed images of its first-generation pod prototype, which will be used at the DevLoop test site in Nevada to test aerodynamics. - Virgin Hyperloop One Virgin Hyperloop One is working with several governments and partners to help advance their technology and construction in countries like India, the United States, Belgium and the United Arab Emirates. - is an American research company formed using a crowd collaboration approach with more than 800 engineers and professionals located around the world. The company is working closely with the United States, United Arab Emirates and France where it is currently building a test track outside the town of Toulouse, uncoincidentally home to the European Multinational Aerospace corporationAirbus. Hyperloop Transportation Technology (HTT) - , a Canadian company designing and manufacturing ultra-high-speed tube transportation technology and vehicles.  Powered by environmentally-sustainable solar/electric energy in a system that is unaffected by weather conditions, TransPod’s system enables passenger and cargo travel that is faster than airline travel. The "Pods" are being designed to travel at over 1,000 km/h between cities using fully electric propulsion and zero need for fossil fuels. When it comes to cargo, the vehicles will be able to carry payloads of 10–15 tons. Transpod Inc. - , a student team from the Technical University of Munich who went on to win 1st place 3 years in a row at the Hyperloop Pod Competition. The team is now working to develop a full-scale Hyperloop system. TUM Hyperloop My opinion on the concept However revolutionary, life-changing and futuristic the concept is, some of my views on the Hyperloop are not all positive. Here are, in my opinion, the pros and cons of the Hyperloop projects. Hyperloop pros: - The benefits for the environment. One of the aims of the Hyperloop is to offer a greener mode of transport, thanks to the lack of friction due to magnetic levitation and vacuum-sealed tubes, the vehicles require less energy to reach ultra-high speeds and travel long distances. Some companies also plan to have solar panels along the top of the tubes to make the Hyperloop completely carbon neutral. - The practicality. The Hyperloop is designed to put an end to train delays and endless queuing by being completely automated and having very regular pods (about every 2-5 minutes). - The speed. Probably the most obvious benefit is the speed that the Hyperloop will be able to reach. Some pods are planning to travel at speeds over 1000 km/h (eventually reaching the speed of sound), so travel times between cities will be massively reduced. - Living and working flexibility. By being able to travel from one city to another in minutes, you could live and work in two different cities without a long commute. Hyperloop cons: - The initial cost. Creating a fully functional intercity Hyperloop will cost a huge amount of money, Virgin Hyperloop One gave a presentation citing an average cost for Hyperloop of $25-27 million (£18-£20 million) per mile just for the technology excluding land acquisition. This is just an average so some specific routes may cost even more than that. - Should we be able to get from city to city so fast? This is very much up for debate but some people might argue that having so many different people rushing in and out of cities will be very annoying. If you're somebody who easily gets annoyed by tourists, imagine how many more there will be when you no longer have to go on a 7-hour drive from one end of the country to the other. The bottom line Whether you are for or against having a 5th mode of transportation, there is no doubt that the Hyperloop concept is intriguing. Personally, I look forward to finding out more about this project and discover the new technology that these companies are innovating. This story was originally published on my tech blog, , where I cover stories on how tech impacts our lives, ! The Detechtor check it out

Musk's Open-Source Hyperloop: Players in the Race to Create the First

Talk to your data! You can view the API documentation here: http://docs.dhignite.com/ What if, instead of running complex SQL scripts, you could simply ask your database a question? What were my sales yesterday? What were my top selling products in June? This natural search capability has become more common over the past year as companies such as ThoughtSpot, Salesforce, and Tableau all develop similar technologies. This trend of “data democratization” is forcing us to leverage existing technology in new ways. The idea that data should be accessible to the average end user, not confined to data analysts or forced to go through a complex queuing system where time and convenience often rule the day, is our new expectation. Data should be accessible beyond the dashboards and beyond analysts. That is why we developed a natural language to SQL API and interface. We utilize the latest in natural language processing and machine learning to convert questions into structured SQL queries. Below you can see that we have utilized the API as part of a chat interface. You can see the user asks a question, the engine contrasts the question against the database metadata and then return an answer. You can also see the SQL that was generated as part of that response. We are now ready to make this API publicly available, so that others can build similar natural search capabilities into their own products. No more forms for generating reports, instead use natural search to empower the user to ask new questions. You can view the API documentation here: http://docs.dhignite.com/ Sending a request for a SQL-query, based on a natural language questions is simple. { "token": "1242ab77d1202aff87bd0b9e96e5a436", "usertoken": ["1242ab77d1202aff87bd0b9e96e5a436"], "database": "foodmart_demo", "params": "total sales" } This request will generate the following response; First it evaluates the “foodmart_demo” database metadata and then produces the SQL response. {"status": "OK","data": {"trash_list": []},"result": " ","method": "server.getSql"} SELECT SUM(sales_fact.store_sales) as `sum.sales_fact.store_sales`\nFROM sales_fact\n User credentials In API v1 we use simple token-based authentication and authorization. To access the Engine API you need the master token and additional user group’s tokens. You will need additional tokens if you want to create several user groups with different access levels. By default, the admin group exists and the admin token is equal to the master token. Each token is a string (32 bytes length), for example “1242ab77d1202aff87bd0b9e96e5a436”. If you are our client, then you already have such a token. Otherwise, use a string “demo” instead of a token. In this case, you will have read-only access to the “foodmart_demo” database configuration only. The Engine Server Endpoint To access the Engine API you need the Engine Server Endpoint URL. For most users it is: https://msg.dhignite.com/api/1.1/nlq 1.1 is the API version number. Database Configurations To respond to a user request, the server needs to have the database metadata. It is JSON-based file. The “demo” user has access to the “foodmart_demo” configuration (usually, another user also has access to this configuration). You need to place the database configuration file at the .Msg Cloud Processing Server (We will do that for you). You can place the finished file or the administrator will create an “empty” file for you, and you will change it using the API or the site. In this manual, all examples will use the “foodmart_demo” database configuration. Demo of API in Action You can sign up on for access to a demo account so that you can utilize the API as part of a chat interface here: http://docs.dhignite.com/demo/ Please reach out directly or through the website for any question about the system.

Introducing the First Natural Language to SQL API

Have you ever rotate an ImageView before? It’s quite simple to rotate an ImageView, as that could simply be done by even in the layout xml code with the attribute. android:rotation A simple example of code as below <CustomImageView
    android:id="@+id/image_on"
    android:layout_width="60dp"
    android:layout_height="60dp"
    android:rotation="-6"
    android:scaleType="centerCrop"
    android:src="@drawable/simpleimage"/> The image generated is rotated to the left as expected. It’s all good until it got inspected by sharp eyes (of a good designer), will bring to light that it is not good, especially on lower resolution devices. (Shhhh … this would make a good “interview test material” for designer :P) An enlarged image of the rotated ImageView is as below … Jagged all over the edges You would notice the rough jagged edges. Can’t we just apply anti-alias on it? Applying anti-alias should help the smoother the edges between different color within the image. But unfortunately for the edges of the image will not be anti-alias, as Android doesn’t anti-alias across it’s view. Trying to be smart, we could add padding, margin, or even use background image to , hopefully Android would be smart to blend them to smooth out the rough jagged edges. Sorry, they don’t help. There are several that recommend turning off Hardware Acceleration for the particular view, but it doesn’t help in my case as well. stackoverflow So how did you do it? What I did was to experiment adding some transparent border on all the sides of my image and save as PNG, then use that image to rotate. Bingo! … the edge got anti-aliased, and as smooth as I like. Check out below, smooth smooth edges! Jagged cleared in all edges But wait… we don’t always have the image readily that we could manually change by adding transparent border to it. Even if we do, it’s so much trouble to do so. This is not feasible! Adding transparent border programmatically Given that we are sure that transparent border does help, perhaps we could do it programmatically. So, I try to expand a Canvas by 1 px on all sides but it turn out that this is not as simple as I thought, as stated in this ,. stackoverflow So given that we can’t add 1 px, so now I cheat…. I shrink the image by 1 px for all sides, by painting the bitmap through a shader. That will leave the side of the image as a transparent padding of 1px each. The code as below (it is added into the function of my that inherit from . void onDraw(Canvas canvas) CustomImageView ImageView if (getDrawable() instanceof BitmapDrawable) {

    Paint paint = new Paint();
    paint.setAntiAlias(true);
    Bitmap bitmap = ((BitmapDrawable) getDrawable()).getBitmap();
    BitmapShader shader = 
       new BitmapShader(bitmap, 
            Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);

    Matrix matrix = new Matrix();
    float scale;

   /* Note: this piece of code handling like Centre-Crop scaling */   
   if (bitmap.getWidth() > bitmap.getHeight()) {
        scale = (float)canvas.getHeight() 
                    / (float) bitmap.getHeight();
        matrix.setScale(scale, scale);
        matrix.postTranslate(
         (canvas.getWidth() - bitmap.getWidth() * scale) * 0.5f, 0);
    
    } else {
        scale = (float)canvas.getWidth() 
                    / (float) bitmap.getWidth();
        matrix.setScale(scale, scale);
        matrix.postTranslate(0, 
         (canvas.getHeight() - bitmap.getHeight() * scale) * 0.5f);
    }

    shader.setLocalMatrix(matrix);
    paint.setShader(shader);

    /* this is where I shrink the image by 1px each side, 
       move it to the center */
    canvas.translate(1, 1);
    canvas.drawRect(
     0.0f, 0.0f, canvas.getWidth()-2, canvas.getHeight()-2, paint);
} With the above code, you’ll get the exact jagged-clear image that I show above. The actual image although shrink by 1 px on each side, but due to the anti-aliasing effect, it makes it seems expanded 1 px as well, hence canceling the shrink look of 1 px. Some Caveat on the Code It only handle the Center-Crop scaling. It didn’t take into consideration the padding added to the . CustomImageView It could be optimized by moving some object creation outside the function. For simplicity, I put them all in a function here. onDraw My hope is Android would automatically by default handle anti-aliasing for all the View’s edges when it is rotated. To me the above is still a ‘hacky’ way of achieving it. If you have a better ‘hack’ to it, do share. Elye Project (@elye_project) | Twitter

Stories, News & Mentions about SIMSCALE

Simscale’s Stories on HackerNoon

Simscale's News & Mentions